config.c:2: * usb/gadget/config.c -- simplify building config descriptors
config.c:18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
config.c:31: * usb_descriptor_fillbuf - fill buffer with descriptors
config.c:49:		return -EINVAL;
config.c:53:		unsigned		len = (*src)->bLength;
config.c:56:			return -EINVAL;
config.c:58:		buflen -= len;
config.c:61:	return dest - (u8 *)buf;
config.c:66: * usb_gadget_config_buf - builts a complete configuration descriptor
config.c:69: * @desc: Null-terminated vector of pointers to the descriptors (interface,
config.c:97:		return -EINVAL;
config.c:102:			length - USB_DT_CONFIG_SIZE, desc);
config.c:107:		return -EINVAL;
config.c:110:	cp->bLength = USB_DT_CONFIG_SIZE;
config.c:111:	cp->bDescriptorType = USB_DT_CONFIG;
config.c:112:	cp->wTotalLength = cpu_to_le16(len);
config.c:113:	cp->bmAttributes |= USB_CONFIG_ATT_ONE;
dummy_hcd.c:2: * dummy_hcd.c -- Dummy/Loopback USB host and device emulator driver.
dummy_hcd.c:21: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
dummy_hcd.c:27: * Linux-USB host controller driver.  USB traffic is simulated; there's
dummy_hcd.c:30: *  - Gadget driver, responding to requests (slave);
dummy_hcd.c:31: *  - Host-side device driver, as already familiar in Linux.
dummy_hcd.c:79:/*-------------------------------------------------------------------------*/
dummy_hcd.c:109:/*-------------------------------------------------------------------------*/
dummy_hcd.c:115: *   - Configurable:  direction (in/out), type (bulk, iso, etc), and endpoint
dummy_hcd.c:116: *     number can be changed.  Names like "ep-a" are used for this type.
dummy_hcd.c:118: *   - Fixed Function:  in other cases.  some characteristics may be mutable;
dummy_hcd.c:119: *     that'd be hardware-specific.  Names like "ep12out-bulk" are used.
dummy_hcd.c:131:	"ep-a", "ep-b", "ep-c", "ep-d", "ep-e", "ep-f",
dummy_hcd.c:134:	"ep1in-bulk", "ep2out-bulk", "ep3in-iso", "ep4out-iso", "ep5in-int",
dummy_hcd.c:135:	"ep6in-bulk", "ep7out-bulk", "ep8in-iso", "ep9out-iso", "ep10in-int",
dummy_hcd.c:136:	"ep11in-bulk", "ep12out-bulk", "ep13in-iso", "ep14out-iso",
dummy_hcd.c:137:		"ep15in-int",
dummy_hcd.c:140:	"ep1out-bulk", "ep2in-bulk",
dummy_hcd.c:180:	return (struct dummy *) (hcd->hcd_priv);
dummy_hcd.c:190:	return dummy_to_hcd(dum)->self.controller;
dummy_hcd.c:195:	return container_of (ep->gadget, struct dummy, gadget);
dummy_hcd.c:210:/*-------------------------------------------------------------------------*/
dummy_hcd.c:223:/*-------------------------------------------------------------------------*/
dummy_hcd.c:233:	(dum->port_status & USB_PORT_STAT_ENABLE)
dummy_hcd.c:244:	if (!_ep || !desc || ep->desc || _ep->name == ep0name
dummy_hcd.c:245:			|| desc->bDescriptorType != USB_DT_ENDPOINT)
dummy_hcd.c:246:		return -EINVAL;
dummy_hcd.c:248:	if (!dum->driver || !is_enabled (dum))
dummy_hcd.c:249:		return -ESHUTDOWN;
dummy_hcd.c:250:	max = le16_to_cpu(desc->wMaxPacketSize) & 0x3ff;
dummy_hcd.c:260:	retval = -EINVAL;
dummy_hcd.c:261:	switch (desc->bmAttributes & 0x03) {
dummy_hcd.c:263:		if (strstr (ep->ep.name, "-iso")
dummy_hcd.c:264:				|| strstr (ep->ep.name, "-int")) {
dummy_hcd.c:267:		switch (dum->gadget.speed) {
dummy_hcd.c:284:		if (strstr (ep->ep.name, "-iso")) /* bulk is ok */
dummy_hcd.c:287:		switch (dum->gadget.speed) {
dummy_hcd.c:303:		if (strstr (ep->ep.name, "-bulk")
dummy_hcd.c:304:				|| strstr (ep->ep.name, "-int"))
dummy_hcd.c:307:		switch (dum->gadget.speed) {
dummy_hcd.c:325:	_ep->maxpacket = max;
dummy_hcd.c:326:	ep->desc = desc;
dummy_hcd.c:328:	dev_dbg (dummy_dev(dum), "enabled %s (ep%d%s-%s) maxpacket %d\n",
dummy_hcd.c:329:		_ep->name,
dummy_hcd.c:330:		desc->bEndpointAddress & 0x0f,
dummy_hcd.c:331:		(desc->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
dummy_hcd.c:333:		 switch (desc->bmAttributes & 0x03) {
dummy_hcd.c:352:	while (!list_empty (&ep->queue)) {
dummy_hcd.c:355:		req = list_entry (ep->queue.next, struct dummy_request, queue);
dummy_hcd.c:356:		list_del_init (&req->queue);
dummy_hcd.c:357:		req->req.status = -ESHUTDOWN;
dummy_hcd.c:359:		spin_unlock (&dum->lock);
dummy_hcd.c:360:		req->req.complete (&ep->ep, &req->req);
dummy_hcd.c:361:		spin_lock (&dum->lock);
dummy_hcd.c:373:	if (!_ep || !ep->desc || _ep->name == ep0name)
dummy_hcd.c:374:		return -EINVAL;
dummy_hcd.c:377:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:378:	ep->desc = NULL;
dummy_hcd.c:381:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:383:	dev_dbg (dummy_dev(dum), "disabled %s\n", _ep->name);
dummy_hcd.c:401:	INIT_LIST_HEAD (&req->queue);
dummy_hcd.c:402:	return &req->req;
dummy_hcd.c:412:	if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
dummy_hcd.c:416:	WARN_ON (!list_empty (&req->queue));
dummy_hcd.c:434:	if (!dum->driver)
dummy_hcd.c:466:	if (!_req || !list_empty (&req->queue) || !_req->complete)
dummy_hcd.c:467:		return -EINVAL;
dummy_hcd.c:470:	if (!_ep || (!ep->desc && _ep->name != ep0name))
dummy_hcd.c:471:		return -EINVAL;
dummy_hcd.c:474:	if (!dum->driver || !is_enabled (dum))
dummy_hcd.c:475:		return -ESHUTDOWN;
dummy_hcd.c:479:			ep, _req, _ep->name, _req->length, _req->buf);
dummy_hcd.c:482:	_req->status = -EINPROGRESS;
dummy_hcd.c:483:	_req->actual = 0;
dummy_hcd.c:484:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:486:	/* implement an emulated single-request FIFO */
dummy_hcd.c:487:	if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
dummy_hcd.c:488:			list_empty (&dum->fifo_req.queue) &&
dummy_hcd.c:489:			list_empty (&ep->queue) &&
dummy_hcd.c:490:			_req->length <= FIFO_SIZE) {
dummy_hcd.c:491:		req = &dum->fifo_req;
dummy_hcd.c:492:		req->req = *_req;
dummy_hcd.c:493:		req->req.buf = dum->fifo_buf;
dummy_hcd.c:494:		memcpy (dum->fifo_buf, _req->buf, _req->length);
dummy_hcd.c:495:		req->req.context = dum;
dummy_hcd.c:496:		req->req.complete = fifo_complete;
dummy_hcd.c:498:		spin_unlock (&dum->lock);
dummy_hcd.c:499:		_req->actual = _req->length;
dummy_hcd.c:500:		_req->status = 0;
dummy_hcd.c:501:		_req->complete (_ep, _req);
dummy_hcd.c:502:		spin_lock (&dum->lock);
dummy_hcd.c:504:	list_add_tail (&req->queue, &ep->queue);
dummy_hcd.c:505:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:517:	int			retval = -EINVAL;
dummy_hcd.c:526:	if (!dum->driver)
dummy_hcd.c:527:		return -ESHUTDOWN;
dummy_hcd.c:529:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:530:	list_for_each_entry (req, &ep->queue, queue) {
dummy_hcd.c:531:		if (&req->req == _req) {
dummy_hcd.c:532:			list_del_init (&req->queue);
dummy_hcd.c:533:			_req->status = -ECONNRESET;
dummy_hcd.c:538:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:543:				req, _ep->name, _req->length, _req->buf);
dummy_hcd.c:544:		_req->complete (_ep, _req);
dummy_hcd.c:556:		return -EINVAL;
dummy_hcd.c:559:	if (!dum->driver)
dummy_hcd.c:560:		return -ESHUTDOWN;
dummy_hcd.c:562:		ep->halted = 0;
dummy_hcd.c:563:	else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) &&
dummy_hcd.c:564:			!list_empty (&ep->queue))
dummy_hcd.c:565:		return -EAGAIN;
dummy_hcd.c:567:		ep->halted = 1;
dummy_hcd.c:589:/*-------------------------------------------------------------------------*/
dummy_hcd.c:605:	if ((dum->devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) == 0
dummy_hcd.c:606:			|| !(dum->port_status & (1 << USB_PORT_FEAT_SUSPEND)))
dummy_hcd.c:607:		return -EINVAL;
dummy_hcd.c:610:	dum->resuming = 1;
dummy_hcd.c:611:	dum->port_status |= (1 << USB_PORT_FEAT_C_SUSPEND);
dummy_hcd.c:621:		dum->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
dummy_hcd.c:623:		dum->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
dummy_hcd.c:633:/*-------------------------------------------------------------------------*/
dummy_hcd.c:641:	if (!dum->driver || !dum->driver->function)
dummy_hcd.c:643:	return scnprintf (buf, PAGE_SIZE, "%s\n", dum->driver->function);
dummy_hcd.c:647:/*-------------------------------------------------------------------------*/
dummy_hcd.c:652: * This is basically hardware-specific; there's usually only one real USB
dummy_hcd.c:678:	strcpy (dum->gadget.dev.bus_id, "udc");
dummy_hcd.c:679:	dum->gadget.dev.parent = dummy_dev(dum);
dummy_hcd.c:680:	dum->gadget.dev.release = dummy_udc_release;
dummy_hcd.c:682:	rc = device_register (&dum->gadget.dev);
dummy_hcd.c:684:		device_create_file (&dum->gadget.dev, &dev_attr_function);
dummy_hcd.c:691:	device_remove_file (&dum->gadget.dev, &dev_attr_function);
dummy_hcd.c:692:	device_unregister (&dum->gadget.dev);
dummy_hcd.c:702:		return -EINVAL;
dummy_hcd.c:703:	if (dum->driver)
dummy_hcd.c:704:		return -EBUSY;
dummy_hcd.c:705:	if (!driver->bind || !driver->unbind || !driver->setup
dummy_hcd.c:706:			|| driver->speed == USB_SPEED_UNKNOWN)
dummy_hcd.c:707:		return -EINVAL;
dummy_hcd.c:713:	dum->gadget.name = gadget_name;
dummy_hcd.c:714:	dum->gadget.ops = &dummy_ops;
dummy_hcd.c:715:	dum->gadget.is_dualspeed = 1;
dummy_hcd.c:717:	dum->devstatus = 0;
dummy_hcd.c:718:	dum->resuming = 0;
dummy_hcd.c:720:	INIT_LIST_HEAD (&dum->gadget.ep_list);
dummy_hcd.c:722:		struct dummy_ep	*ep = &dum->ep [i];
dummy_hcd.c:726:		ep->ep.name = ep_name [i];
dummy_hcd.c:727:		ep->ep.ops = &dummy_ep_ops;
dummy_hcd.c:728:		list_add_tail (&ep->ep.ep_list, &dum->gadget.ep_list);
dummy_hcd.c:729:		ep->halted = ep->already_seen = ep->setup_stage = 0;
dummy_hcd.c:730:		ep->ep.maxpacket = ~0;
dummy_hcd.c:731:		ep->last_io = jiffies;
dummy_hcd.c:732:		ep->gadget = &dum->gadget;
dummy_hcd.c:733:		ep->desc = NULL;
dummy_hcd.c:734:		INIT_LIST_HEAD (&ep->queue);
dummy_hcd.c:737:	dum->gadget.ep0 = &dum->ep [0].ep;
dummy_hcd.c:738:	dum->ep [0].ep.maxpacket = 64;
dummy_hcd.c:739:	list_del_init (&dum->ep [0].ep.ep_list);
dummy_hcd.c:740:	INIT_LIST_HEAD(&dum->fifo_req.queue);
dummy_hcd.c:742:	dum->driver = driver;
dummy_hcd.c:743:	dum->gadget.dev.driver = &driver->driver;
dummy_hcd.c:745:			driver->driver.name);
dummy_hcd.c:746:	if ((retval = driver->bind (&dum->gadget)) != 0) {
dummy_hcd.c:747:		dum->driver = NULL;
dummy_hcd.c:748:		dum->gadget.dev.driver = NULL;
dummy_hcd.c:752:	// FIXME: Check these calls for errors and re-order
dummy_hcd.c:753:	driver->driver.bus = dum->gadget.dev.parent->bus;
dummy_hcd.c:754:	driver_register (&driver->driver);
dummy_hcd.c:756:	device_bind_driver (&dum->gadget.dev);
dummy_hcd.c:759:	dum->port_status |= USB_PORT_STAT_CONNECTION
dummy_hcd.c:772:	dum->address = 0;
dummy_hcd.c:777:	list_for_each_entry (ep, &dum->gadget.ep_list, ep.ep_list)
dummy_hcd.c:780:	/* driver now does any non-usb quiescing necessary */
dummy_hcd.c:782:		spin_unlock (&dum->lock);
dummy_hcd.c:783:		driver->disconnect (&dum->gadget);
dummy_hcd.c:784:		spin_lock (&dum->lock);
dummy_hcd.c:795:		return -ENODEV;
dummy_hcd.c:796:	if (!driver || driver != dum->driver)
dummy_hcd.c:797:		return -EINVAL;
dummy_hcd.c:800:			driver->driver.name);
dummy_hcd.c:802:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:804:	dum->port_status &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE |
dummy_hcd.c:806:	dum->port_status |= (1 << USB_PORT_FEAT_C_CONNECTION);
dummy_hcd.c:807:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:809:	driver->unbind (&dum->gadget);
dummy_hcd.c:810:	dum->driver = NULL;
dummy_hcd.c:812:	device_release_driver (&dum->gadget.dev);
dummy_hcd.c:814:	driver_unregister (&driver->driver);
dummy_hcd.c:824:	return -ENOSYS;
dummy_hcd.c:828:/*-------------------------------------------------------------------------*/
dummy_hcd.c:852:	if (!urb->transfer_buffer && urb->transfer_buffer_length)
dummy_hcd.c:853:		return -EINVAL;
dummy_hcd.c:857:		return -ENOMEM;
dummy_hcd.c:858:	urbp->urb = urb;
dummy_hcd.c:861:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:863:	if (!dum->udev) {
dummy_hcd.c:864:		dum->udev = urb->dev;
dummy_hcd.c:865:		usb_get_dev (dum->udev);
dummy_hcd.c:866:	} else if (unlikely (dum->udev != urb->dev))
dummy_hcd.c:869:	list_add_tail (&urbp->urbp_list, &dum->urbp_list);
dummy_hcd.c:870:	urb->hcpriv = urbp;
dummy_hcd.c:871:	if (usb_pipetype (urb->pipe) == PIPE_CONTROL)
dummy_hcd.c:872:		urb->error_count = 1;		/* mark as a new urb */
dummy_hcd.c:875:	if (!timer_pending (&dum->timer))
dummy_hcd.c:876:		mod_timer (&dum->timer, jiffies + 1);
dummy_hcd.c:878:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:890:	spin_lock (&urb->lock);
dummy_hcd.c:891:	if (urb->status == -EINPROGRESS)
dummy_hcd.c:892:		urb->status = status;
dummy_hcd.c:893:	spin_unlock (&urb->lock);
dummy_hcd.c:904:	list_for_each_entry (req, &ep->queue, queue) {
dummy_hcd.c:909:		/* 1..N packets of ep->ep.maxpacket each ... the last one
dummy_hcd.c:916:		host_len = urb->transfer_buffer_length - urb->actual_length;
dummy_hcd.c:917:		dev_len = req->req.length - req->req.actual;
dummy_hcd.c:922:		to_host = usb_pipein (urb->pipe);
dummy_hcd.c:929:			if (limit < ep->ep.maxpacket && limit < len)
dummy_hcd.c:936:			if (len > ep->ep.maxpacket) {
dummy_hcd.c:938:				len -= (len % ep->ep.maxpacket);
dummy_hcd.c:940:			is_short = (len % ep->ep.maxpacket) != 0;
dummy_hcd.c:943:			ubuf = urb->transfer_buffer + urb->actual_length;
dummy_hcd.c:944:			rbuf = req->req.buf + req->req.actual;
dummy_hcd.c:949:			ep->last_io = jiffies;
dummy_hcd.c:951:			limit -= len;
dummy_hcd.c:952:			urb->actual_length += len;
dummy_hcd.c:953:			req->req.actual += len;
dummy_hcd.c:961:		 * need to emulate such data-in-flight.  so we only show part
dummy_hcd.c:966:				req->req.status = 0;
dummy_hcd.c:969:				req->req.status = 0;
dummy_hcd.c:971:					maybe_set_status (urb, -EOVERFLOW);
dummy_hcd.c:974:						(urb->transfer_flags
dummy_hcd.c:976:						? -EREMOTEIO : 0);
dummy_hcd.c:980:					req->req.status = -EOVERFLOW;
dummy_hcd.c:982:					req->req.status = 0;
dummy_hcd.c:987:			if (req->req.length == req->req.actual
dummy_hcd.c:988:					&& !req->req.zero)
dummy_hcd.c:989:				req->req.status = 0;
dummy_hcd.c:990:			if (urb->transfer_buffer_length == urb->actual_length
dummy_hcd.c:991:					&& !(urb->transfer_flags
dummy_hcd.c:997:		/* device side completion --> continuable */
dummy_hcd.c:998:		if (req->req.status != -EINPROGRESS) {
dummy_hcd.c:999:			list_del_init (&req->queue);
dummy_hcd.c:1001:			spin_unlock (&dum->lock);
dummy_hcd.c:1002:			req->req.complete (&ep->ep, &req->req);
dummy_hcd.c:1003:			spin_lock (&dum->lock);
dummy_hcd.c:1009:		/* host side completion --> terminate */
dummy_hcd.c:1010:		if (urb->status != -EINPROGRESS)
dummy_hcd.c:1022:	int	limit = ep->ep.maxpacket;
dummy_hcd.c:1024:	if (dum->gadget.speed == USB_SPEED_HIGH) {
dummy_hcd.c:1028:		tmp = le16_to_cpu(ep->desc->wMaxPacketSize);
dummy_hcd.c:1037:#define is_active(dum)	((dum->port_status & \
dummy_hcd.c:1049:		return &dum->ep [0];
dummy_hcd.c:1051:		struct dummy_ep	*ep = &dum->ep [i];
dummy_hcd.c:1053:		if (!ep->desc)
dummy_hcd.c:1055:		if (ep->desc->bEndpointAddress == address)
dummy_hcd.c:1082:	switch (dum->gadget.speed) {
dummy_hcd.c:1100:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:1102:	if (!dum->udev) {
dummy_hcd.c:1105:		spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:1112:		dum->ep [i].already_seen = 0;
dummy_hcd.c:1116:	list_for_each_entry_safe (urbp, tmp, &dum->urbp_list, urbp_list) {
dummy_hcd.c:1123:		urb = urbp->urb;
dummy_hcd.c:1124:		if (urb->status != -EINPROGRESS) {
dummy_hcd.c:1128:		type = usb_pipetype (urb->pipe);
dummy_hcd.c:1130:		/* used up this frame's non-periodic bandwidth?
dummy_hcd.c:1138:		address = usb_pipeendpoint (urb->pipe);
dummy_hcd.c:1139:		if (usb_pipein (urb->pipe))
dummy_hcd.c:1147:			maybe_set_status (urb, -EPROTO);
dummy_hcd.c:1151:		if (ep->already_seen)
dummy_hcd.c:1153:		ep->already_seen = 1;
dummy_hcd.c:1154:		if (ep == &dum->ep [0] && urb->error_count) {
dummy_hcd.c:1155:			ep->setup_stage = 1;	/* a new urb */
dummy_hcd.c:1156:			urb->error_count = 0;
dummy_hcd.c:1158:		if (ep->halted && !ep->setup_stage) {
dummy_hcd.c:1161:					ep->ep.name, urb);
dummy_hcd.c:1162:			maybe_set_status (urb, -EPIPE);
dummy_hcd.c:1168:		if (ep == &dum->ep [0] && ep->setup_stage) {
dummy_hcd.c:1173:			setup = *(struct usb_ctrlrequest*) urb->setup_packet;
dummy_hcd.c:1177:			if (setup.wLength != urb->transfer_buffer_length) {
dummy_hcd.c:1178:				maybe_set_status (urb, -EOVERFLOW);
dummy_hcd.c:1183:			list_for_each_entry (req, &ep->queue, queue) {
dummy_hcd.c:1184:				list_del_init (&req->queue);
dummy_hcd.c:1185:				req->req.status = -EOVERFLOW;
dummy_hcd.c:1189:				spin_unlock (&dum->lock);
dummy_hcd.c:1190:				req->req.complete (&ep->ep, &req->req);
dummy_hcd.c:1191:				spin_lock (&dum->lock);
dummy_hcd.c:1192:				ep->already_seen = 0;
dummy_hcd.c:1200:			ep->last_io = jiffies;
dummy_hcd.c:1201:			ep->setup_stage = 0;
dummy_hcd.c:1202:			ep->halted = 0;
dummy_hcd.c:1207:				dum->address = setup.wValue;
dummy_hcd.c:1220:						value = -EOPNOTSUPP;
dummy_hcd.c:1223:						dum->devstatus |=
dummy_hcd.c:1233:						value = -EOPNOTSUPP;
dummy_hcd.c:1236:					ep2->halted = 1;
dummy_hcd.c:1245:						dum->devstatus &= ~(1 <<
dummy_hcd.c:1251:						value = -EOPNOTSUPP;
dummy_hcd.c:1259:						value = -EOPNOTSUPP;
dummy_hcd.c:1262:					ep2->halted = 0;
dummy_hcd.c:1279:					buf = (char *)urb->transfer_buffer;
dummy_hcd.c:1280:					if (urb->transfer_buffer_length > 0) {
dummy_hcd.c:1285:		value = -EOPNOTSUPP;
dummy_hcd.c:1288:	buf [0] = ep2->halted;
dummy_hcd.c:1292:								dum->devstatus;
dummy_hcd.c:1296:					if (urb->transfer_buffer_length > 1)
dummy_hcd.c:1298:					urb->actual_length = min (2,
dummy_hcd.c:1299:						urb->transfer_buffer_length);
dummy_hcd.c:1310:				spin_unlock (&dum->lock);
dummy_hcd.c:1311:				value = dum->driver->setup (&dum->gadget,
dummy_hcd.c:1313:				spin_lock (&dum->lock);
dummy_hcd.c:1324:				if (value != -EOPNOTSUPP)
dummy_hcd.c:1326:						"setup --> %d\n",
dummy_hcd.c:1328:				maybe_set_status (urb, -EPIPE);
dummy_hcd.c:1329:				urb->actual_length = 0;
dummy_hcd.c:1335:		/* non-control requests */
dummy_hcd.c:1337:		switch (usb_pipetype (urb->pipe)) {
dummy_hcd.c:1339:			/* FIXME is it urb->interval since the last xfer?
dummy_hcd.c:1340:			 * use urb->iso_frame_desc[i].
dummy_hcd.c:1345:			maybe_set_status (urb, -ENOSYS);
dummy_hcd.c:1349:			/* FIXME is it urb->interval since the last xfer?
dummy_hcd.c:1358:			ep->last_io = jiffies;
dummy_hcd.c:1364:		if (urb->status == -EINPROGRESS)
dummy_hcd.c:1368:		urb->hcpriv = NULL;
dummy_hcd.c:1369:		list_del (&urbp->urbp_list);
dummy_hcd.c:1372:			ep->already_seen = ep->setup_stage = 0;
dummy_hcd.c:1374:		spin_unlock (&dum->lock);
dummy_hcd.c:1376:		spin_lock (&dum->lock);
dummy_hcd.c:1382:	if (!list_empty (&dum->urbp_list))
dummy_hcd.c:1383:		mod_timer (&dum->timer, jiffies + msecs_to_jiffies(1));
dummy_hcd.c:1385:		usb_put_dev (dum->udev);
dummy_hcd.c:1386:		dum->udev = NULL;
dummy_hcd.c:1389:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:1392:/*-------------------------------------------------------------------------*/
dummy_hcd.c:1409:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:1410:	if (!(dum->port_status & PORT_C_MASK))
dummy_hcd.c:1415:			dum->port_status);
dummy_hcd.c:1418:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:1426:	desc->bDescriptorType = 0x29;
dummy_hcd.c:1427:	desc->bDescLength = 9;
dummy_hcd.c:1428:	desc->wHubCharacteristics = __constant_cpu_to_le16 (0x0001);
dummy_hcd.c:1429:	desc->bNbrPorts = 1;
dummy_hcd.c:1430:	desc->bitmap [0] = 0xff;
dummy_hcd.c:1431:	desc->bitmap [1] = 0xff;
dummy_hcd.c:1447:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:1454:			if (dum->port_status & (1 << USB_PORT_FEAT_SUSPEND)) {
dummy_hcd.c:1456:				dum->resuming = 1;
dummy_hcd.c:1457:				dum->re_timeout = jiffies +
dummy_hcd.c:1462:			dum->port_status = 0;
dummy_hcd.c:1463:			dum->resuming = 0;
dummy_hcd.c:1464:			stop_activity(dum, dum->driver);
dummy_hcd.c:1467:			dum->port_status &= ~(1 << wValue);
dummy_hcd.c:1478:			retval = -EPIPE;
dummy_hcd.c:1483:		if (dum->resuming && time_after (jiffies, dum->re_timeout)) {
dummy_hcd.c:1484:			dum->port_status |= (1 << USB_PORT_FEAT_C_SUSPEND);
dummy_hcd.c:1485:			dum->port_status &= ~(1 << USB_PORT_FEAT_SUSPEND);
dummy_hcd.c:1486:			dum->resuming = 0;
dummy_hcd.c:1487:			dum->re_timeout = 0;
dummy_hcd.c:1488:			if (dum->driver && dum->driver->resume) {
dummy_hcd.c:1489:				spin_unlock (&dum->lock);
dummy_hcd.c:1490:				dum->driver->resume (&dum->gadget);
dummy_hcd.c:1491:				spin_lock (&dum->lock);
dummy_hcd.c:1494:		if ((dum->port_status & (1 << USB_PORT_FEAT_RESET)) != 0
dummy_hcd.c:1495:				&& time_after (jiffies, dum->re_timeout)) {
dummy_hcd.c:1496:			dum->port_status |= (1 << USB_PORT_FEAT_C_RESET);
dummy_hcd.c:1497:			dum->port_status &= ~(1 << USB_PORT_FEAT_RESET);
dummy_hcd.c:1498:			dum->re_timeout = 0;
dummy_hcd.c:1499:			if (dum->driver) {
dummy_hcd.c:1500:				dum->port_status |= USB_PORT_STAT_ENABLE;
dummy_hcd.c:1502:				dum->gadget.speed = dum->driver->speed;
dummy_hcd.c:1503:				dum->gadget.ep0->maxpacket = 64;
dummy_hcd.c:1504:				switch (dum->gadget.speed) {
dummy_hcd.c:1506:					dum->port_status |=
dummy_hcd.c:1510:					dum->gadget.ep0->maxpacket = 8;
dummy_hcd.c:1511:					dum->port_status |=
dummy_hcd.c:1515:					dum->gadget.speed = USB_SPEED_FULL;
dummy_hcd.c:1520:		((u16 *) buf)[0] = cpu_to_le16 (dum->port_status);
dummy_hcd.c:1521:		((u16 *) buf)[1] = cpu_to_le16 (dum->port_status >> 16);
dummy_hcd.c:1524:		retval = -EPIPE;
dummy_hcd.c:1529:			if ((dum->port_status & (1 << USB_PORT_FEAT_SUSPEND))
dummy_hcd.c:1531:				dum->port_status |=
dummy_hcd.c:1533:				if (dum->driver && dum->driver->suspend) {
dummy_hcd.c:1534:					spin_unlock (&dum->lock);
dummy_hcd.c:1535:					dum->driver->suspend (&dum->gadget);
dummy_hcd.c:1536:					spin_lock (&dum->lock);
dummy_hcd.c:1542:			if (dum->port_status & USB_PORT_STAT_ENABLE) {
dummy_hcd.c:1543:				dum->port_status &= ~(USB_PORT_STAT_ENABLE
dummy_hcd.c:1546:				if (dum->driver) {
dummy_hcd.c:1549:					stop_activity (dum, dum->driver);
dummy_hcd.c:1555:			dum->re_timeout = jiffies + msecs_to_jiffies(50);
dummy_hcd.c:1558:			dum->port_status |= (1 << wValue);
dummy_hcd.c:1568:		retval = -EPIPE;
dummy_hcd.c:1570:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:1575:/*-------------------------------------------------------------------------*/
dummy_hcd.c:1580:	int ep = usb_pipeendpoint (urb->pipe);
dummy_hcd.c:1586:		 switch (urb->dev->speed) {
dummy_hcd.c:1592:		ep, ep ? (usb_pipein (urb->pipe) ? "in" : "out") : "",
dummy_hcd.c:1594:		 switch (usb_pipetype (urb->pipe)) { \
dummy_hcd.c:1596:		 case PIPE_BULK:	s = "-bulk"; break; \
dummy_hcd.c:1597:		 case PIPE_INTERRUPT:	s = "-int"; break; \
dummy_hcd.c:1598:		 default: 		s = "-iso"; break; \
dummy_hcd.c:1600:		urb->actual_length, urb->transfer_buffer_length);
dummy_hcd.c:1612:	spin_lock_irqsave (&dum->lock, flags);
dummy_hcd.c:1613:	list_for_each_entry (urbp, &dum->urbp_list, urbp_list) {
dummy_hcd.c:1616:		temp = show_urb (buf, PAGE_SIZE - size, urbp->urb);
dummy_hcd.c:1620:	spin_unlock_irqrestore (&dum->lock, flags);
dummy_hcd.c:1637:	 * just like more familiar pci-based HCDs.
dummy_hcd.c:1639:	spin_lock_init (&dum->lock);
dummy_hcd.c:1641:	init_timer (&dum->timer);
dummy_hcd.c:1642:	dum->timer.function = dummy_timer;
dummy_hcd.c:1643:	dum->timer.data = (unsigned long) dum;
dummy_hcd.c:1645:	INIT_LIST_HEAD (&dum->urbp_list);
dummy_hcd.c:1647:	root = usb_alloc_dev (NULL, &hcd->self, 0);
dummy_hcd.c:1649:		return -ENOMEM;
dummy_hcd.c:1652:	hcd->state = USB_STATE_RUNNING;
dummy_hcd.c:1653:	root->speed = USB_SPEED_HIGH;
dummy_hcd.c:1659:		hcd->state = USB_STATE_QUIESCING;
dummy_hcd.c:1663:	/* only show a low-power port: just 8mA */
dummy_hcd.c:1667:		usb_disconnect (&hcd->self.root_hub);
dummy_hcd.c:1671:	/* FIXME 'urbs' should be a per-device thing, maybe in usbcore */
dummy_hcd.c:1674:	dum->started = 1;
dummy_hcd.c:1683:	if (!dum->started)
dummy_hcd.c:1685:	dum->started = 0;
dummy_hcd.c:1689:	usb_gadget_unregister_driver (dum->driver);
dummy_hcd.c:1695:/*-------------------------------------------------------------------------*/
dummy_hcd.c:1734:		return -ENOMEM;
dummy_hcd.c:1741:	hcd->self.controller = dev;
dummy_hcd.c:1743:	/* FIXME don't require the pci-based buffer/alloc impls;
dummy_hcd.c:1753:	hcd->self.bus_name = dev->bus_id;
dummy_hcd.c:1754:	usb_register_bus (&hcd->self);
dummy_hcd.c:1774:	hcd->state = USB_STATE_QUIESCING;
dummy_hcd.c:1777:	usb_disconnect (&hcd->self.root_hub);
dummy_hcd.c:1779:	hcd->driver->stop (hcd);
dummy_hcd.c:1780:	hcd->state = USB_STATE_HALT;
dummy_hcd.c:1785:	usb_deregister_bus (&hcd->self);
dummy_hcd.c:1789:/*-------------------------------------------------------------------------*/
dummy_hcd.c:1815:/*-------------------------------------------------------------------------*/
dummy_hcd.c:1822:		return -ENODEV;
epautoconf.c:2: * epautoconf.c -- endpoint autoconfiguration for usb gadget drivers
epautoconf.c:18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
epautoconf.c:50: *	- ep1, ep2, ... address is fixed, not direction or type
epautoconf.c:51: *	- ep1in, ep2out, ... address and direction are fixed, not type
epautoconf.c:52: *	- ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
epautoconf.c:53: *	- ep1in-bulk, ep2out-iso, ... all three are fixed
epautoconf.c:54: *	- ep-* ... no functionality restrictions
epautoconf.c:56: * Type suffixes are "-bulk", "-iso", or "-int".  Numbers are decimal.
epautoconf.c:74:	if (0 != ep->driver_data)
epautoconf.c:78:	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
epautoconf.c:83:	if ('e' != ep->name[0])
epautoconf.c:86:	/* type-restriction:  "-iso", "-bulk", or "-int".
epautoconf.c:87:	 * direction-restriction:  "in", "out".
epautoconf.c:89:	if ('-' != ep->name[2]) {
epautoconf.c:90:		tmp = strrchr (ep->name, '-');
epautoconf.c:95:				 * except the toggle-quirky iso-synch kind
epautoconf.c:97:				if ('s' == tmp[2])	// == "-iso"
epautoconf.c:99:				/* for now, avoid PXA "interrupt-in";
epautoconf.c:107:				if ('b' != tmp[1])	// != "-bulk"
epautoconf.c:111:				if ('s' != tmp[2])	// != "-iso"
epautoconf.c:115:			tmp = ep->name + strlen (ep->name);
epautoconf.c:118:		/* direction-restriction:  "..in-..", "out-.." */
epautoconf.c:119:		tmp--;
epautoconf.c:121:			if (desc->bEndpointAddress & USB_DIR_IN) {
epautoconf.c:135:	max = 0x7ff & le16_to_cpup (&desc->wMaxPacketSize);
epautoconf.c:139:		if (!gadget->is_dualspeed && max > 64)
epautoconf.c:145:		if (ep->maxpacket < max)
epautoconf.c:147:		if (!gadget->is_dualspeed && max > 1023)
epautoconf.c:151:		if ((desc->wMaxPacketSize & __constant_cpu_to_le16(3<<11))) {
epautoconf.c:152:			if (!gadget->is_dualspeed)
epautoconf.c:162:	if (isdigit (ep->name [2])) {
epautoconf.c:163:		u8	num = simple_strtol (&ep->name [2], NULL, 10);
epautoconf.c:164:		desc->bEndpointAddress |= num;
epautoconf.c:166:	} else if (desc->bEndpointAddress & USB_DIR_IN) {
epautoconf.c:169:		desc->bEndpointAddress = USB_DIR_IN | in_epnum;
epautoconf.c:174:		desc->bEndpointAddress |= epnum;
epautoconf.c:179:		int size = ep->maxpacket;
epautoconf.c:181:		/* min() doesn't work on bitfields with gcc-3.5 */
epautoconf.c:184:		desc->wMaxPacketSize = cpu_to_le16(size);
epautoconf.c:194:	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
epautoconf.c:195:		if (0 == strcmp (ep->name, name))
epautoconf.c:202: * usb_ep_autoconfig - choose an endpoint matching the descriptor
epautoconf.c:223: * On success, this returns an un-claimed usb_ep, and modifies the endpoint
epautoconf.c:227: * by assigning ep->driver_data to some non-null value.
epautoconf.c:239:	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
epautoconf.c:241:	/* First, apply chip-specific "best usage" knowledge.
epautoconf.c:245:		/* ep-e, ep-f are PIO with only 64 byte fifos */
epautoconf.c:246:		ep = find_ep (gadget, "ep-e");
epautoconf.c:249:		ep = find_ep (gadget, "ep-f");
epautoconf.c:256:			ep = find_ep (gadget, "ep3-bulk");
epautoconf.c:260:				&& (USB_DIR_IN & desc->bEndpointAddress)) {
epautoconf.c:262:			ep = find_ep (gadget, "ep2-bulk");
epautoconf.c:269:		ep = find_ep (gadget, "ep3in-bulk");
epautoconf.c:274:		ep = find_ep (gadget, "ep1-bulk");
epautoconf.c:280:	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
epautoconf.c:290: * usb_ep_autoconfig_reset - reset endpoint autoconfig state
epautoconf.c:295: * state such as ep->driver_data and the record of assigned endpoints
epautoconf.c:302:	list_for_each_entry (ep, &gadget->ep_list, ep_list) {
epautoconf.c:303:		ep->driver_data = NULL;
ether.c:2: * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
ether.c:4: * Copyright (C) 2003-2004 David Brownell
ether.c:5: * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
ether.c:19: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
ether.c:61:/*-------------------------------------------------------------------------*/
ether.c:64: * Ethernet gadget driver -- with CDC and non-CDC options
ether.c:70: * this USB-IF standard as its open-systems interoperability solution;
ether.c:74: * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
ether.c:75: * link-level setup only requires activating the configuration.
ether.c:100:/*-------------------------------------------------------------------------*/
ether.c:129:/* This version autoconfigures as much as possible at run-time.
ether.c:131: * It also ASSUMES a self-powered device, without remote wakeup,
ether.c:138:/*-------------------------------------------------------------------------*/
ether.c:140:/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
ether.c:141: * Instead:  allocate your own, using normal USB-IF procedures.
ether.c:148:#define CDC_PRODUCT_NUM	0xa4a1		/* Linux-USB Ethernet Gadget */
ether.c:151: * ARM Linux has used for ethernet-over-usb, both with sa1100 and
ether.c:152: * with pxa250.  We're protocol-compatible, if the host-side drivers
ether.c:154: * drivers that need to hard-wire endpoint numbers have a hook.
ether.c:158: * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
ether.c:159: * doesn't handle control-OUT).
ether.c:167: * the non-RNDIS configuration.
ether.c:175: * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
ether.c:209:/*-------------------------------------------------------------------------*/
ether.c:211:/* Include CDC support if we could run on CDC-capable hardware. */
ether.c:246:/* For CDC-incapable hardware, choose the simple cdc subset.
ether.c:258:/* use non-CDC for backwards compatibility */
ether.c:266:/*-------------------------------------------------------------------------*/
ether.c:276:/* for dual-speed hardware, use deeper queues at highspeed */
ether.c:278:	(DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
ether.c:283:#define	BITRATE(g) ((g->speed == USB_SPEED_HIGH) ? 4800000 : 120000)
ether.c:292:/*-------------------------------------------------------------------------*/
ether.c:295:	printk(level "%s: " fmt , (d)->net->name , ## args)
ether.c:320:/*-------------------------------------------------------------------------*/
ether.c:324: * also optional class-specific notification interrupt transfer.
ether.c:355: * an RNDIS-only configuration.
ether.c:357: * FIXME define some higher-powered configurations to make it easier
ether.c:424: * RNDIS shares a lot with CDC-Ethernet, since it's a variant of
ether.c:425: * the CDC-ACM (modem) spec.
ether.c:579: * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
ether.c:582: * encapsulated commands (vendor-specific, using control-OUT).
ether.c:661: * "Simple" CDC-subset option is a simple vendor-neutral model that most
ether.c:848:#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
ether.c:861:/*-------------------------------------------------------------------------*/
ether.c:863:/* descriptors that are built on-demand */
ether.c:873:/* static strings, in UTF-8 */
ether.c:894:	.language	= 0x0409,	/* en-us */
ether.c:921:		return -EINVAL;
ether.c:937:	/* for now, don't advertise srp-only devices */
ether.c:944:	((struct usb_config_descriptor *) buf)->bDescriptorType = type;
ether.c:948:/*-------------------------------------------------------------------------*/
ether.c:968:	if (strcmp (ep->name, EP_IN_NAME) == 0) {
ether.c:969:		d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
ether.c:970:		ep->driver_data = dev;
ether.c:971:		dev->in_ep = ep;
ether.c:972:		dev->in = d;
ether.c:975:	} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
ether.c:976:		d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
ether.c:977:		ep->driver_data = dev;
ether.c:978:		dev->out_ep = ep;
ether.c:979:		dev->out = d;
ether.c:983:			strcmp (ep->name, EP_STATUS_NAME) == 0) {
ether.c:986:		d = ep_desc (dev->gadget, &hs_status_desc, &fs_status_desc);
ether.c:991:		ep->driver_data = dev;
ether.c:992:		dev->status_ep = ep;
ether.c:993:		dev->status = d;
ether.c:1012:	if (strcmp (ep->name, EP_IN_NAME) == 0) {
ether.c:1013:		d = ep_desc (dev->gadget, &hs_source_desc, &fs_source_desc);
ether.c:1018:		ep->driver_data = dev;
ether.c:1019:		dev->in_ep = ep;
ether.c:1020:		dev->in = d;
ether.c:1023:	} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
ether.c:1024:		d = ep_desc (dev->gadget, &hs_sink_desc, &fs_sink_desc);
ether.c:1029:		ep->driver_data = dev;
ether.c:1030:		dev->out_ep = ep;
ether.c:1031:		dev->out = d;
ether.c:1043:	struct usb_gadget	*gadget = dev->gadget;
ether.c:1047:		if (!dev->rndis && dev->cdc) {
ether.c:1055:		if (dev->rndis && strcmp (ep->name, EP_STATUS_NAME) == 0) {
ether.c:1060:				ep->driver_data = dev;
ether.c:1061:				dev->status_ep = ep;
ether.c:1062:				dev->status = d;
ether.c:1077:		ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
ether.c:1080:	if (!result && (!dev->in_ep || !dev->out_ep))
ether.c:1081:		result = -ENODEV;
ether.c:1089:		if (dev->status_ep)
ether.c:1090:			(void) usb_ep_disable (dev->status_ep);
ether.c:1092:		dev->status_ep = NULL;
ether.c:1093:		dev->status = NULL;
ether.c:1095:		if (dev->rndis || !dev->cdc) {
ether.c:1096:			if (dev->in_ep)
ether.c:1097:				(void) usb_ep_disable (dev->in_ep);
ether.c:1098:			if (dev->out_ep)
ether.c:1099:				(void) usb_ep_disable (dev->out_ep);
ether.c:1102:		dev->in_ep = NULL;
ether.c:1103:		dev->in = NULL;
ether.c:1104:		dev->out_ep = NULL;
ether.c:1105:		dev->out = NULL;
ether.c:1108:	/* activate non-CDC configs right away
ether.c:1112:	if (dev->rndis || !dev->cdc) {
ether.c:1113:		netif_carrier_on (dev->net);
ether.c:1114:		if (netif_running (dev->net)) {
ether.c:1115:			spin_unlock (&dev->lock);
ether.c:1117:			spin_lock (&dev->lock);
ether.c:1133:	if (dev->config == 0)
ether.c:1138:	netif_stop_queue (dev->net);
ether.c:1139:	netif_carrier_off (dev->net);
ether.c:1144:	if (dev->in_ep) {
ether.c:1145:		usb_ep_disable (dev->in_ep);
ether.c:1146:		while (likely (!list_empty (&dev->tx_reqs))) {
ether.c:1147:			req = container_of (dev->tx_reqs.next,
ether.c:1149:			list_del (&req->list);
ether.c:1150:			usb_ep_free_request (dev->in_ep, req);
ether.c:1152:		dev->in_ep = NULL;
ether.c:1154:	if (dev->out_ep) {
ether.c:1155:		usb_ep_disable (dev->out_ep);
ether.c:1156:		while (likely (!list_empty (&dev->rx_reqs))) {
ether.c:1157:			req = container_of (dev->rx_reqs.next,
ether.c:1159:			list_del (&req->list);
ether.c:1160:			usb_ep_free_request (dev->out_ep, req);
ether.c:1162:		dev->out_ep = NULL;
ether.c:1165:	if (dev->status_ep) {
ether.c:1166:		usb_ep_disable (dev->status_ep);
ether.c:1167:		dev->status_ep = NULL;
ether.c:1169:	dev->config = 0;
ether.c:1179:	struct usb_gadget	*gadget = dev->gadget;
ether.c:1181:	if (number == dev->config)
ether.c:1185:			&& dev->config
ether.c:1186:			&& atomic_read (&dev->tx_qlen) != 0) {
ether.c:1189:		return -ESPIPE;
ether.c:1194:	dev->cdc_filter = 0x000f;
ether.c:1198:		dev->rndis = 0;
ether.c:1203:		dev->rndis = 1;
ether.c:1208:		result = -EINVAL;
ether.c:1217:		usb_gadget_vbus_draw(dev->gadget,
ether.c:1218:				dev->gadget->is_otg ? 8 : 100);
ether.c:1224:		usb_gadget_vbus_draw(dev->gadget, power);
ether.c:1226:		switch (gadget->speed) {
ether.c:1234:		dev->config = number;
ether.c:1237:				dev->rndis
ether.c:1239:					: (dev->cdc
ether.c:1246:/*-------------------------------------------------------------------------*/
ether.c:1250: * and RNDIS also defines its own bit-incompatible notifications
ether.c:1271:	struct cdc_notification	*event = req->buf;
ether.c:1272:	int			value = req->status;
ether.c:1273:	struct eth_dev		*dev = ep->driver_data;
ether.c:1276:	if (event->bNotificationType == CDC_NOTIFY_NETWORK_CONNECTION
ether.c:1278:		event->bmRequestType = 0xA1;
ether.c:1279:		event->bNotificationType = CDC_NOTIFY_SPEED_CHANGE;
ether.c:1280:		event->wValue = __constant_cpu_to_le16 (0);
ether.c:1281:		event->wIndex = __constant_cpu_to_le16 (1);
ether.c:1282:		event->wLength = __constant_cpu_to_le16 (8);
ether.c:1285:		event->data [0] = event->data [1] =
ether.c:1286:			(dev->gadget->speed == USB_SPEED_HIGH)
ether.c:1290:		req->length = 16;
ether.c:1292:		DEBUG (dev, "send SPEED_CHANGE --> %d\n", value);
ether.c:1296:		DEBUG (dev, "event %02x --> %d\n",
ether.c:1297:			event->bNotificationType, value);
ether.c:1300:	usb_ep_free_buffer (ep, req->buf, req->dma, 16);
ether.c:1316:	 * unlink-one primitive has way too many error modes.
ether.c:1319:	usb_ep_disable (dev->status_ep);
ether.c:1320:	usb_ep_enable (dev->status_ep, dev->status);
ether.c:1322:	/* FIXME make these allocations static like dev->req */
ether.c:1323:	req = usb_ep_alloc_request (dev->status_ep, GFP_ATOMIC);
ether.c:1328:	req->buf = usb_ep_alloc_buffer (dev->status_ep, 16,
ether.c:1329:				&dev->req->dma, GFP_ATOMIC);
ether.c:1330:	if (req->buf == 0) {
ether.c:1333:		usb_ep_free_request (dev->status_ep, req);
ether.c:1340:	event = req->buf;
ether.c:1341:	event->bmRequestType = 0xA1;
ether.c:1342:	event->bNotificationType = CDC_NOTIFY_NETWORK_CONNECTION;
ether.c:1343:	event->wValue = __constant_cpu_to_le16 (1);	/* connected */
ether.c:1344:	event->wIndex = __constant_cpu_to_le16 (1);
ether.c:1345:	event->wLength = 0;
ether.c:1347:	req->length = 8;
ether.c:1348:	req->complete = eth_status_complete;
ether.c:1349:	value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
ether.c:1351:		DEBUG (dev, "status buf queue --> %d\n", value);
ether.c:1352:		usb_ep_free_buffer (dev->status_ep,
ether.c:1353:				req->buf, dev->req->dma, 16);
ether.c:1360:/*-------------------------------------------------------------------------*/
ether.c:1364:	if (req->status || req->actual != req->length)
ether.c:1365:		DEBUG ((struct eth_dev *) ep->driver_data,
ether.c:1366:				"setup complete --> %d, %d/%d\n",
ether.c:1367:				req->status, req->actual, req->length);
ether.c:1394:	if (req->status || req->actual != req->length)
ether.c:1395:		DEBUG ((struct eth_dev *) ep->driver_data,
ether.c:1396:			"rndis response complete --> %d, %d/%d\n",
ether.c:1397:			req->status, req->actual, req->length);
ether.c:1404:	struct eth_dev          *dev = ep->driver_data;
ether.c:1408:	spin_lock(&dev->lock);
ether.c:1409:	status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf);
ether.c:1412:	spin_unlock(&dev->lock);
ether.c:1419: * handled lower down.  CDC has a number of less-common features:
ether.c:1421: *  - two interfaces:  control, and ethernet data
ether.c:1422: *  - Ethernet data interface has two altsettings:  default, and active
ether.c:1423: *  - class-specific descriptors for the control interface
ether.c:1424: *  - class-specific control requests
ether.c:1430:	struct usb_request	*req = dev->req;
ether.c:1431:	int			value = -EOPNOTSUPP;
ether.c:1433:	/* descriptors just go into the pre-allocated ep0 buffer,
ether.c:1436:	req->complete = eth_setup_complete;
ether.c:1437:	switch (ctrl->bRequest) {
ether.c:1440:		if (ctrl->bRequestType != USB_DIR_IN)
ether.c:1442:		switch (ctrl->wValue >> 8) {
ether.c:1445:			value = min (ctrl->wLength, (u16) sizeof device_desc);
ether.c:1446:			memcpy (req->buf, &device_desc, value);
ether.c:1450:			if (!gadget->is_dualspeed)
ether.c:1452:			value = min (ctrl->wLength, (u16) sizeof dev_qualifier);
ether.c:1453:			memcpy (req->buf, &dev_qualifier, value);
ether.c:1457:			if (!gadget->is_dualspeed)
ether.c:1462:			value = config_buf (gadget->speed, req->buf,
ether.c:1463:					ctrl->wValue >> 8,
ether.c:1464:					ctrl->wValue & 0xff,
ether.c:1465:					gadget->is_otg);
ether.c:1467:				value = min (ctrl->wLength, (u16) value);
ether.c:1472:					ctrl->wValue & 0xff, req->buf);
ether.c:1474:				value = min (ctrl->wLength, (u16) value);
ether.c:1480:		if (ctrl->bRequestType != 0)
ether.c:1482:		if (gadget->a_hnp_support)
ether.c:1484:		else if (gadget->a_alt_hnp_support)
ether.c:1486:		spin_lock (&dev->lock);
ether.c:1487:		value = eth_set_config (dev, ctrl->wValue, GFP_ATOMIC);
ether.c:1488:		spin_unlock (&dev->lock);
ether.c:1491:		if (ctrl->bRequestType != USB_DIR_IN)
ether.c:1493:		*(u8 *)req->buf = dev->config;
ether.c:1494:		value = min (ctrl->wLength, (u16) 1);
ether.c:1498:		if (ctrl->bRequestType != USB_RECIP_INTERFACE
ether.c:1499:				|| !dev->config
ether.c:1500:				|| ctrl->wIndex > 1)
ether.c:1502:		if (!dev->cdc && ctrl->wIndex != 0)
ether.c:1504:		spin_lock (&dev->lock);
ether.c:1516:		switch (ctrl->wIndex) {
ether.c:1518:			if (ctrl->wValue != 0)
ether.c:1520:			if (dev->status_ep) {
ether.c:1521:				usb_ep_disable (dev->status_ep);
ether.c:1522:				usb_ep_enable (dev->status_ep, dev->status);
ether.c:1527:			if (ctrl->wValue > 1)
ether.c:1529:			usb_ep_disable (dev->in_ep);
ether.c:1530:			usb_ep_disable (dev->out_ep);
ether.c:1534:			 * the non-default interface clears filters etc.
ether.c:1536:			if (ctrl->wValue == 1) {
ether.c:1537:				usb_ep_enable (dev->in_ep, dev->in);
ether.c:1538:				usb_ep_enable (dev->out_ep, dev->out);
ether.c:1539:				netif_carrier_on (dev->net);
ether.c:1540:				if (dev->status_ep)
ether.c:1542:				if (netif_running (dev->net)) {
ether.c:1543:					spin_unlock (&dev->lock);
ether.c:1545:					spin_lock (&dev->lock);
ether.c:1548:				netif_stop_queue (dev->net);
ether.c:1549:				netif_carrier_off (dev->net);
ether.c:1556:		 * all non-PXA hardware talks real CDC ...
ether.c:1558:		dev_warn (&gadget->dev, "set_interface ignored!\n");
ether.c:1562:		spin_unlock (&dev->lock);
ether.c:1565:		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
ether.c:1566:				|| !dev->config
ether.c:1567:				|| ctrl->wIndex > 1)
ether.c:1569:		if (!(dev->cdc || dev->rndis) && ctrl->wIndex != 0)
ether.c:1573:		if (dev->rndis || ctrl->wIndex != 1)
ether.c:1574:			*(u8 *)req->buf = 0;
ether.c:1576:			*(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0;
ether.c:1577:		value = min (ctrl->wLength, (u16) 1);
ether.c:1585:		if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
ether.c:1586:				|| !dev->cdc
ether.c:1587:				|| dev->rndis
ether.c:1588:				|| ctrl->wLength != 0
ether.c:1589:				|| ctrl->wIndex > 1)
ether.c:1591:		DEBUG (dev, "NOP packet filter %04x\n", ctrl->wValue);
ether.c:1596:		dev->cdc_filter = ctrl->wValue;
ether.c:1606:		if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
ether.c:1607:				|| !dev->rndis
ether.c:1608:				|| ctrl->wLength > USB_BUFSIZ
ether.c:1609:				|| ctrl->wValue
ether.c:1611:					!= ctrl->wIndex)
ether.c:1614:		value = ctrl->wLength;
ether.c:1615:		req->complete = rndis_command_complete;
ether.c:1621:					== ctrl->bRequestType
ether.c:1622:				&& dev->rndis
ether.c:1623:				// && ctrl->wLength >= 0x0400
ether.c:1624:				&& !ctrl->wValue
ether.c:1626:					== ctrl->wIndex) {
ether.c:1630:			buf = rndis_get_next_response (dev->rndis_config,
ether.c:1633:				memcpy (req->buf, buf, value);
ether.c:1634:				req->complete = rndis_response_complete;
ether.c:1635:				rndis_free_response(dev->rndis_config, buf);
ether.c:1645:			ctrl->bRequestType, ctrl->bRequest,
ether.c:1646:			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
ether.c:1651:		req->length = value;
ether.c:1652:		req->zero = value < ctrl->wLength
ether.c:1653:				&& (value % gadget->ep0->maxpacket) == 0;
ether.c:1654:		value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
ether.c:1656:			DEBUG (dev, "ep_queue --> %d\n", value);
ether.c:1657:			req->status = 0;
ether.c:1658:			eth_setup_complete (gadget->ep0, req);
ether.c:1672:	spin_lock_irqsave (&dev->lock, flags);
ether.c:1673:	netif_stop_queue (dev->net);
ether.c:1674:	netif_carrier_off (dev->net);
ether.c:1676:	spin_unlock_irqrestore (&dev->lock, flags);
ether.c:1685:/*-------------------------------------------------------------------------*/
ether.c:1696:		return -ERANGE;
ether.c:1697:	/* no zero-length packet read wanted after mtu-sized packets */
ether.c:1698:	if (((new_mtu + sizeof (struct ethhdr)) % dev->in_ep->maxpacket) == 0)
ether.c:1699:		return -EDOM;
ether.c:1700:	net->mtu = new_mtu;
ether.c:1706:	return &((struct eth_dev *)netdev_priv(net))->stats;
ether.c:1712:	strlcpy(p->driver, shortname, sizeof p->driver);
ether.c:1713:	strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
ether.c:1714:	strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
ether.c:1715:	strlcpy (p->bus_info, dev->gadget->dev.bus_id, sizeof p->bus_info);
ether.c:1721:	return dev->gadget->speed != USB_SPEED_UNKNOWN;
ether.c:1731:	if (test_and_set_bit (flag, &dev->todo))
ether.c:1733:	if (!schedule_work (&dev->work))
ether.c:1745:	int			retval = -ENOMEM;
ether.c:1756:	 * pad to end-of-packet.  That's potentially nice for speed,
ether.c:1759:	size = (sizeof (struct ethhdr) + dev->net->mtu + RX_EXTRA);
ether.c:1760:	size += dev->out_ep->maxpacket - 1;
ether.c:1762:	if (dev->rndis)
ether.c:1765:	size -= size % dev->out_ep->maxpacket;
ether.c:1772:	req->buf = skb->data;
ether.c:1773:	req->length = size;
ether.c:1774:	req->complete = rx_complete;
ether.c:1775:	req->context = skb;
ether.c:1777:	retval = usb_ep_queue (dev->out_ep, req, gfp_flags);
ether.c:1778:	if (retval == -ENOMEM)
ether.c:1782:		DEBUG (dev, "rx submit --> %d\n", retval);
ether.c:1784:		spin_lock (&dev->lock);
ether.c:1785:		list_add (&req->list, &dev->rx_reqs);
ether.c:1786:		spin_unlock (&dev->lock);
ether.c:1793:	struct sk_buff	*skb = req->context;
ether.c:1794:	struct eth_dev	*dev = ep->driver_data;
ether.c:1795:	int		status = req->status;
ether.c:1801:		skb_put (skb, req->actual);
ether.c:1804:		if (dev->rndis)
ether.c:1805:			rndis_rm_hdr (req->buf, &(skb->len));
ether.c:1807:		if (ETH_HLEN > skb->len || skb->len > ETH_FRAME_LEN) {
ether.c:1808:			dev->stats.rx_errors++;
ether.c:1809:			dev->stats.rx_length_errors++;
ether.c:1810:			DEBUG (dev, "rx length %d\n", skb->len);
ether.c:1814:		skb->dev = dev->net;
ether.c:1815:		skb->protocol = eth_type_trans (skb, dev->net);
ether.c:1816:		dev->stats.rx_packets++;
ether.c:1817:		dev->stats.rx_bytes += skb->len;
ether.c:1826:	/* software-driven interface shutdown */
ether.c:1827:	case -ECONNRESET:		// unlink
ether.c:1828:	case -ESHUTDOWN:		// disconnect etc
ether.c:1833:	case -ECONNABORTED:		// endpoint reset
ether.c:1834:		DEBUG (dev, "rx %s reset\n", ep->name);
ether.c:1841:	case -EOVERFLOW:
ether.c:1842:		dev->stats.rx_over_errors++;
ether.c:1846:		dev->stats.rx_errors++;
ether.c:1853:	if (!netif_running (dev->net)) {
ether.c:1855:		/* nobody reading rx_reqs, so no dev->lock */
ether.c:1856:		list_add (&req->list, &dev->rx_reqs);
ether.c:1870:		return -ENOMEM;
ether.c:1875:		if (i-- == 0)
ether.c:1878:	while (i--) {
ether.c:1881:			return list_empty (list) ? -ENOMEM : 0;
ether.c:1882:		list_add (&req->list, list);
ether.c:1891:		next = req->list.next;
ether.c:1892:		list_del (&req->list);
ether.c:1907:	status = prealloc (&dev->tx_reqs, dev->in_ep, n, gfp_flags);
ether.c:1910:	status = prealloc (&dev->rx_reqs, dev->out_ep, n, gfp_flags);
ether.c:1924:	clear_bit (WORK_RX_MEMORY, &dev->todo);
ether.c:1927:	spin_lock_irqsave (&dev->lock, flags);
ether.c:1928:	while (!list_empty (&dev->rx_reqs)) {
ether.c:1929:		req = container_of (dev->rx_reqs.next,
ether.c:1931:		list_del_init (&req->list);
ether.c:1932:		spin_unlock_irqrestore (&dev->lock, flags);
ether.c:1939:		spin_lock_irqsave (&dev->lock, flags);
ether.c:1941:	spin_unlock_irqrestore (&dev->lock, flags);
ether.c:1948:	if (test_bit (WORK_RX_MEMORY, &dev->todo)) {
ether.c:1949:		if (netif_running (dev->net))
ether.c:1952:			clear_bit (WORK_RX_MEMORY, &dev->todo);
ether.c:1955:	if (dev->todo)
ether.c:1956:		DEBUG (dev, "work done, flags = 0x%lx\n", dev->todo);
ether.c:1961:	struct sk_buff	*skb = req->context;
ether.c:1962:	struct eth_dev	*dev = ep->driver_data;
ether.c:1964:	switch (req->status) {
ether.c:1966:		dev->stats.tx_errors++;
ether.c:1967:		VDEBUG (dev, "tx err %d\n", req->status);
ether.c:1969:	case -ECONNRESET:		// unlink
ether.c:1970:	case -ESHUTDOWN:		// disconnect etc
ether.c:1973:		dev->stats.tx_bytes += skb->len;
ether.c:1975:	dev->stats.tx_packets++;
ether.c:1977:	spin_lock (&dev->lock);
ether.c:1978:	list_add (&req->list, &dev->tx_reqs);
ether.c:1979:	spin_unlock (&dev->lock);
ether.c:1982:	atomic_dec (&dev->tx_qlen);
ether.c:1983:	if (netif_carrier_ok (dev->net))
ether.c:1984:		netif_wake_queue (dev->net);
ether.c:1990:	int			length = skb->len;
ether.c:1995:	/* FIXME check dev->cdc_filter to decide whether to send this,
ether.c:2000:	spin_lock_irqsave (&dev->lock, flags);
ether.c:2001:	req = container_of (dev->tx_reqs.next, struct usb_request, list);
ether.c:2002:	list_del (&req->list);
ether.c:2003:	if (list_empty (&dev->tx_reqs))
ether.c:2005:	spin_unlock_irqrestore (&dev->lock, flags);
ether.c:2012:	if (dev->rndis) {
ether.c:2023:		length = skb->len;
ether.c:2026:	req->buf = skb->data;
ether.c:2027:	req->context = skb;
ether.c:2028:	req->complete = tx_complete;
ether.c:2030:	/* use zlp framing on tx for strict CDC-Ether conformance,
ether.c:2034:	req->zero = 1;
ether.c:2035:	if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
ether.c:2038:	req->length = length;
ether.c:2042:	req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
ether.c:2043:		? ((atomic_read (&dev->tx_qlen) % TX_DELAY) != 0)
ether.c:2047:	retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
ether.c:2053:		net->trans_start = jiffies;
ether.c:2054:		atomic_inc (&dev->tx_qlen);
ether.c:2061:		dev->stats.tx_dropped++;
ether.c:2063:		spin_lock_irqsave (&dev->lock, flags);
ether.c:2064:		if (list_empty (&dev->tx_reqs))
ether.c:2066:		list_add (&req->list, &dev->tx_reqs);
ether.c:2067:		spin_unlock_irqrestore (&dev->lock, flags);
ether.c:2072:/*-------------------------------------------------------------------------*/
ether.c:2082:		if (rndis_signal_connect (dev->rndis_config))
ether.c:2085:		if (rndis_signal_disconnect (dev->rndis_config))
ether.c:2093:	if (req->status || req->actual != req->length)
ether.c:2094:		DEBUG ((struct eth_dev *) ep->driver_data,
ether.c:2095:			"rndis control ack complete --> %d, %d/%d\n",
ether.c:2096:			req->status, req->actual, req->length);
ether.c:2098:	usb_ep_free_buffer(ep, req->buf, req->dma, 8);
ether.c:2109:	if (!dev->status_ep) {
ether.c:2111:		return -ENODEV;
ether.c:2115:	resp = usb_ep_alloc_request (dev->status_ep, GFP_ATOMIC);
ether.c:2118:		return -ENOMEM;
ether.c:2121:	resp->buf = usb_ep_alloc_buffer (dev->status_ep, 8,
ether.c:2122:					 &resp->dma, GFP_ATOMIC);
ether.c:2123:	if (!resp->buf) {
ether.c:2125:		usb_ep_free_request (dev->status_ep, resp);
ether.c:2126:		return -ENOMEM;
ether.c:2132:	resp->length = 8;
ether.c:2133:	resp->complete = rndis_control_ack_complete;
ether.c:2135:	*((u32 *) resp->buf) = __constant_cpu_to_le32 (1);
ether.c:2136:	*((u32 *) resp->buf + 1) = __constant_cpu_to_le32 (0);
ether.c:2138:	length = usb_ep_queue (dev->status_ep, resp, GFP_ATOMIC);
ether.c:2140:		resp->status = 0;
ether.c:2141:		rndis_control_ack_complete (dev->status_ep, resp);
ether.c:2157:	atomic_set (&dev->tx_qlen, 0);
ether.c:2158:	netif_wake_queue (dev->net);
ether.c:2160:	if (dev->rndis) {
ether.c:2161:		rndis_set_param_medium (dev->rndis_config,
ether.c:2163:					BITRATE(dev->gadget));
ether.c:2174:	if (netif_carrier_ok (dev->net))
ether.c:2187:		dev->stats.rx_packets, dev->stats.tx_packets, 
ether.c:2188:		dev->stats.rx_errors, dev->stats.tx_errors
ether.c:2192:	if (dev->config) {
ether.c:2193:		usb_ep_disable (dev->in_ep);
ether.c:2194:		usb_ep_disable (dev->out_ep);
ether.c:2195:		if (netif_carrier_ok (dev->net)) {
ether.c:2198:			usb_ep_enable (dev->in_ep, dev->in);
ether.c:2199:			usb_ep_enable (dev->out_ep, dev->out);
ether.c:2201:		if (dev->status_ep) {
ether.c:2202:			usb_ep_disable (dev->status_ep);
ether.c:2203:			usb_ep_enable (dev->status_ep, dev->status);
ether.c:2208:	if (dev->rndis) {
ether.c:2209:		rndis_set_param_medium (dev->rndis_config,
ether.c:2218:/*-------------------------------------------------------------------------*/
ether.c:2227:	rndis_deregister (dev->rndis_config);
ether.c:2232:	if (dev->req) {
ether.c:2233:		usb_ep_free_buffer (gadget->ep0,
ether.c:2234:				dev->req->buf, dev->req->dma,
ether.c:2236:		usb_ep_free_request (gadget->ep0, dev->req);
ether.c:2237:		dev->req = NULL;
ether.c:2240:	unregister_netdev (dev->net);
ether.c:2241:	free_netdev(dev->net);
ether.c:2251:		return c - '0';
ether.c:2254:		return 10 + c - 'A';
ether.c:2285:	int			status = -ENOMEM;
ether.c:2317:		 * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
ether.c:2334:		 * anything less functional on CDC-capable hardware,
ether.c:2337:		dev_err (&gadget->dev,
ether.c:2339:			gadget->name);
ether.c:2340:		return -ENODEV;
ether.c:2344:		gadget->name);
ether.c:2374:			dev_err (&gadget->dev, "idVendor needs idProduct!\n");
ether.c:2375:			return -ENODEV;
ether.c:2392:		dev_err (&gadget->dev,
ether.c:2394:			gadget->name);
ether.c:2395:		return -ENODEV;
ether.c:2397:	EP_IN_NAME = ep->name;
ether.c:2398:	ep->driver_data = ep;	/* claim */
ether.c:2403:	EP_OUT_NAME = ep->name;
ether.c:2404:	ep->driver_data = ep;	/* claim */
ether.c:2413:			EP_STATUS_NAME = ep->name;
ether.c:2414:			ep->driver_data = ep;	/* claim */
ether.c:2416:			dev_err (&gadget->dev,
ether.c:2418:				gadget->name);
ether.c:2419:			return -ENODEV;
ether.c:2448:	/* and that all endpoints are dual-speed */
ether.c:2458:	device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
ether.c:2461:	if (gadget->is_otg) {
ether.c:2475:	spin_lock_init (&dev->lock);
ether.c:2476:	INIT_WORK (&dev->work, eth_work, dev);
ether.c:2477:	INIT_LIST_HEAD (&dev->tx_reqs);
ether.c:2478:	INIT_LIST_HEAD (&dev->rx_reqs);
ether.c:2481:	dev->net = net;
ether.c:2483:	strcpy (net->name, "usb%d");
ether.c:2484:	dev->cdc = cdc;
ether.c:2485:	dev->zlp = zlp;
ether.c:2491:	get_ether_addr(dev_addr, net->dev_addr);
ether.c:2493:		get_ether_addr(host_addr, dev->host_mac);
ether.c:2496:			dev->host_mac [0], dev->host_mac [1],
ether.c:2497:			dev->host_mac [2], dev->host_mac [3],
ether.c:2498:			dev->host_mac [4], dev->host_mac [5]);
ether.c:2505:			dev_err (&gadget->dev, "can't init RNDIS, %d\n",
ether.c:2511:	net->change_mtu = eth_change_mtu;
ether.c:2512:	net->get_stats = eth_get_stats;
ether.c:2513:	net->hard_start_xmit = eth_start_xmit;
ether.c:2514:	net->open = eth_open;
ether.c:2515:	net->stop = eth_stop;
ether.c:2521:	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
ether.c:2522:	if (!dev->req)
ether.c:2524:	dev->req->complete = eth_setup_complete;
ether.c:2525:	dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
ether.c:2526:				&dev->req->dma, GFP_KERNEL);
ether.c:2527:	if (!dev->req->buf) {
ether.c:2528:		usb_ep_free_request (gadget->ep0, dev->req);
ether.c:2533:	dev->gadget = gadget;
ether.c:2535:	gadget->ep0->driver_data = dev;
ether.c:2537:	/* two kinds of host-initiated state changes:
ether.c:2538:	 *  - iff DATA transfer is active, carrier is "on"
ether.c:2539:	 *  - tx queueing enabled if open *and* carrier is "on"
ether.c:2541:	netif_stop_queue (dev->net);
ether.c:2542:	netif_carrier_off (dev->net);
ether.c:2544: 	// SET_NETDEV_DEV (dev->net, &gadget->dev);
ether.c:2545: 	status = register_netdev (dev->net);
ether.c:2550:	INFO (dev, "using %s, OUT %s IN %s%s%s\n", gadget->name,
ether.c:2556:		net->dev_addr [0], net->dev_addr [1],
ether.c:2557:		net->dev_addr [2], net->dev_addr [3],
ether.c:2558:		net->dev_addr [4], net->dev_addr [5]);
ether.c:2562:			dev->host_mac [0], dev->host_mac [1],
ether.c:2563:			dev->host_mac [2], dev->host_mac [3],
ether.c:2564:			dev->host_mac [4], dev->host_mac [5]);
ether.c:2572:		dev->rndis_config = rndis_register (rndis_control_ack);
ether.c:2573:		if (dev->rndis_config < 0) {
ether.c:2575:			unregister_netdev (dev->net);
ether.c:2576:			status = -ENODEV;
ether.c:2581:		rndis_set_host_mac (dev->rndis_config, dev->host_mac);
ether.c:2582:		if (rndis_set_param_dev (dev->rndis_config, dev->net,
ether.c:2583:					 &dev->stats))
ether.c:2585:		if (rndis_set_param_vendor (dev->rndis_config, vendorID,
ether.c:2588:		if (rndis_set_param_medium (dev->rndis_config,
ether.c:2599:	dev_dbg(&gadget->dev, "register_netdev failed, %d\n", status);
ether.c:2605:/*-------------------------------------------------------------------------*/
ether.c:2613:	dev->suspended = 1;
ether.c:2622:	dev->suspended = 0;
ether.c:2625:/*-------------------------------------------------------------------------*/
file_storage.c:2: * file_storage.c -- File-backed USB Storage Gadget, for USB development
file_storage.c:16: * 3. The names of the above-listed copyright holders may not be used
file_storage.c:40: * The File-backed Storage Gadget acts as a USB Mass Storage device,
file_storage.c:43: * illustrates a technique of double-buffering for increased throughput.
file_storage.c:48: * by the "file" module parameter.  Access can be limited to read-only by
file_storage.c:52: * The gadget supports the Control-Bulk (CB), Control-Bulk-Interrupt (CBI),
file_storage.c:53: * and Bulk-Only (also known as Bulk-Bulk-Bulk or BBB) transports, selected
file_storage.c:55: * following protocols: RBC (0x01), ATAPI or SFF-8020i (0x02), QIC-157 (0c03),
file_storage.c:56: * UFI (0x04), SFF-8070i (0x05), and transparent SCSI (0x06), selected by
file_storage.c:63: * files are specified using comma-separated lists for "file" and "ro".
file_storage.c:69: * Requirements are modest; only a bulk-in and a bulk-out endpoint are
file_storage.c:70: * needed (an interrupt-out endpoint is also needed for CBI).  The memory
file_storage.c:72: * Support is included for both full-speed and high-speed operation.
file_storage.c:80: *	ro=b[,b...]		Default false, booleans for read-only access
file_storage.c:87: *					also 1 - 6)
file_storage.c:107: * line means eject) and adjusting a write-enable tab.  Changes to the ro
file_storage.c:119: * callbacks from the controller driver: bulk- and interrupt-request
file_storage.c:120: * completion notifications, endpoint-0 events, and disconnect events.
file_storage.c:129: * for pending signals/exceptions -- all this polling is necessary since
file_storage.c:149: * fsg->state; it won't try to stop the thread if the state is already
file_storage.c:156: * pipeline as being a long one.  Each buffer head contains a bulk-in and
file_storage.c:157: * a bulk-out request pointer (since the buffer can be used for both
file_storage.c:158: * output and input -- directions always are given from the host's
file_storage.c:163: * (fsg->next_buffhd_to_fill) that points to the next buffer head to use.
file_storage.c:177: * Bulk-only specification requires a stall.  In such cases the driver
file_storage.c:181: * specification allows the bulk-out endpoint to halt when the host sends
file_storage.c:183: * The driver will always use the "no-stall" approach for OUT transfers.
file_storage.c:185: * One subtle point concerns sending status-stage responses for ep0
file_storage.c:193: * tag value of the request associated with a long-running exception
file_storage.c:194: * (device-reset, interface-change, or configuration-change).  When the
file_storage.c:195: * exception handler is finished, the status-stage response is submitted
file_storage.c:198: * status-stage response.
file_storage.c:248:/*-------------------------------------------------------------------------*/
file_storage.c:250:#define DRIVER_DESC		"File-backed Storage Gadget"
file_storage.c:264: * Instead:  allocate your own, using normal USB-IF procedures. */
file_storage.c:266:#define DRIVER_PRODUCT_ID	0xa4a5	// Linux-USB File-backed Storage Gadget
file_storage.c:270: * This driver assumes self-powered hardware and has no way for users to
file_storage.c:276:/*-------------------------------------------------------------------------*/
file_storage.c:279:	dev_printk(level , &(f)->gadget->dev , fmt , ## args)
file_storage.c:281:	dev_printk(level , &(l)->dev , fmt , ## args)
file_storage.c:330:/*-------------------------------------------------------------------------*/
file_storage.c:375:MODULE_PARM_DESC(ro, "true to force read-only");
file_storage.c:384:/* In the non-TEST version, only the module parameters listed above
file_storage.c:413:/*-------------------------------------------------------------------------*/
file_storage.c:418:#define USB_PR_BULK	0x50		// Bulk-only
file_storage.c:422:#define USB_SC_8020	0x02		// SFF-8020i, MMC-2, ATAPI (CD-ROM)
file_storage.c:423:#define USB_SC_QIC	0x03		// QIC-157 (tape)
file_storage.c:425:#define USB_SC_8070	0x05		// SFF-8070i (removable)
file_storage.c:428:/* Bulk-only data structures */
file_storage.c:459:/* Bulk-only class specific requests */
file_storage.c:472:/* CBI Accept Device-Specific Command request */
file_storage.c:524:/*-------------------------------------------------------------------------*/
file_storage.c:528: * parts of the driver that aren't used in the non-TEST version.  Even gcc
file_storage.c:564:#define backing_file_is_open(curlun)	((curlun)->filp != NULL)
file_storage.c:576:/* Number of buffers we will use.  2 is enough for double-buffering */
file_storage.c:592:	 * better, if we don't submit any short bulk-out read requests.
file_storage.c:603:	FSG_STATE_COMMAND_PHASE = -10,		// This one isn't used anywhere
file_storage.c:632:	struct usb_ep		*ep0;		// Handy copy of gadget->ep0
file_storage.c:703:	return (fsg->state > FSG_STATE_IDLE);
file_storage.c:706:/* Make bulk-out requests be divisible by the maxpacket size */
file_storage.c:712:	bh->bulk_out_intended_length = length;
file_storage.c:713:	rem = length % fsg->bulk_out_maxpacket;
file_storage.c:715:		length += fsg->bulk_out_maxpacket - rem;
file_storage.c:716:	bh->outreq->length = length;
file_storage.c:726:/*-------------------------------------------------------------------------*/
file_storage.c:754:		length -= num;
file_storage.c:772:	for (i = 0; i < fsg->cmnd_size; ++i)
file_storage.c:773:		sprintf(cmdbuf + i*3, " %02x", fsg->cmnd[i]);
file_storage.c:784:	if (ep == fsg->bulk_in)
file_storage.c:785:		name = "bulk-in";
file_storage.c:786:	else if (ep == fsg->bulk_out)
file_storage.c:787:		name = "bulk-out";
file_storage.c:789:		name = ep->name;
file_storage.c:795:/*-------------------------------------------------------------------------*/
file_storage.c:825:/*-------------------------------------------------------------------------*/
file_storage.c:867:	.bMaxPower =		1,	// self-powered
file_storage.c:891:/* Three full-speed endpoint descriptors: bulk-in, bulk-out,
file_storage.c:892: * and interrupt-in. */
file_storage.c:922:	.bInterval =		32,	// frames -> 32 ms
file_storage.c:986:	.bInterval =		9,	// 2**(9-1) = 256 uframes -> 32 ms
file_storage.c:1000:#define ep_desc(g,fs,hs)	(((g)->speed==USB_SPEED_HIGH) ? (hs) : (fs))
file_storage.c:1004:/* If there's no high speed support, always use the full-speed descriptor. */
file_storage.c:1015:/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
file_storage.c:1024:	.language	= 0x0409,		// en-us
file_storage.c:1032: * also handle different speeds and other-speed requests.
file_storage.c:1038:	enum usb_device_speed			speed = gadget->speed;
file_storage.c:1044:		return -EINVAL;
file_storage.c:1048:		speed = (USB_SPEED_FULL + USB_SPEED_HIGH) - speed;
file_storage.c:1055:	/* for now, don't advertise srp-only devices */
file_storage.c:1056:	if (!gadget->is_otg)
file_storage.c:1060:	((struct usb_config_descriptor *) buf)->bDescriptorType = type;
file_storage.c:1065:/*-------------------------------------------------------------------------*/
file_storage.c:1072:	fsg->thread_wakeup_needed = 1;
file_storage.c:1073:	wake_up_all(&fsg->thread_wqh);
file_storage.c:1082:	/* Do nothing if a higher-priority exception is already in progress.
file_storage.c:1083:	 * If a lower-or-equal priority exception is in progress, preempt it
file_storage.c:1085:	spin_lock_irqsave(&fsg->lock, flags);
file_storage.c:1086:	if (fsg->state <= new_state) {
file_storage.c:1087:		fsg->exception_req_tag = fsg->ep0_req_tag;
file_storage.c:1088:		fsg->state = new_state;
file_storage.c:1089:		thread_task = fsg->thread_task;
file_storage.c:1093:	spin_unlock_irqrestore(&fsg->lock, flags);
file_storage.c:1097:/*-------------------------------------------------------------------------*/
file_storage.c:1102: * Bulk-only device reset. */
file_storage.c:1117:	rc = usb_ep_queue(fsg->ep0, fsg->ep0req, GFP_ATOMIC);
file_storage.c:1118:	if (rc != 0 && rc != -ESHUTDOWN) {
file_storage.c:1121:		WARN(fsg, "error in submission: %s --> %d\n",
file_storage.c:1122:				fsg->ep0->name, rc);
file_storage.c:1129:	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
file_storage.c:1131:	if (req->actual > 0)
file_storage.c:1132:		dump_msg(fsg, fsg->ep0req_name, req->buf, req->actual);
file_storage.c:1133:	if (req->status || req->actual != req->length)
file_storage.c:1134:		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
file_storage.c:1135:				req->status, req->actual, req->length);
file_storage.c:1136:	if (req->status == -ECONNRESET)		// Request was cancelled
file_storage.c:1139:	if (req->status == 0 && req->context)
file_storage.c:1140:		((fsg_routine_t) (req->context))(fsg);
file_storage.c:1144:/*-------------------------------------------------------------------------*/
file_storage.c:1151:	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
file_storage.c:1152:	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
file_storage.c:1154:	if (req->status || req->actual != req->length)
file_storage.c:1155:		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
file_storage.c:1156:				req->status, req->actual, req->length);
file_storage.c:1157:	if (req->status == -ECONNRESET)		// Request was cancelled
file_storage.c:1161:	spin_lock(&fsg->lock);
file_storage.c:1162:	bh->inreq_busy = 0;
file_storage.c:1163:	bh->state = BUF_STATE_EMPTY;
file_storage.c:1164:	spin_unlock(&fsg->lock);
file_storage.c:1170:	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
file_storage.c:1171:	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
file_storage.c:1173:	dump_msg(fsg, "bulk-out", req->buf, req->actual);
file_storage.c:1174:	if (req->status || req->actual != bh->bulk_out_intended_length)
file_storage.c:1175:		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
file_storage.c:1176:				req->status, req->actual,
file_storage.c:1177:				bh->bulk_out_intended_length);
file_storage.c:1178:	if (req->status == -ECONNRESET)		// Request was cancelled
file_storage.c:1182:	spin_lock(&fsg->lock);
file_storage.c:1183:	bh->outreq_busy = 0;
file_storage.c:1184:	bh->state = BUF_STATE_FULL;
file_storage.c:1185:	spin_unlock(&fsg->lock);
file_storage.c:1193:	struct fsg_dev		*fsg = (struct fsg_dev *) ep->driver_data;
file_storage.c:1194:	struct fsg_buffhd	*bh = (struct fsg_buffhd *) req->context;
file_storage.c:1196:	if (req->status || req->actual != req->length)
file_storage.c:1197:		DBG(fsg, "%s --> %d, %u/%u\n", __FUNCTION__,
file_storage.c:1198:				req->status, req->actual, req->length);
file_storage.c:1199:	if (req->status == -ECONNRESET)		// Request was cancelled
file_storage.c:1203:	spin_lock(&fsg->lock);
file_storage.c:1204:	fsg->intreq_busy = 0;
file_storage.c:1205:	bh->state = BUF_STATE_EMPTY;
file_storage.c:1206:	spin_unlock(&fsg->lock);
file_storage.c:1216:/*-------------------------------------------------------------------------*/
file_storage.c:1218:/* Ep0 class-specific handlers.  These always run in_irq. */
file_storage.c:1223:	struct usb_request	*req = fsg->ep0req;
file_storage.c:1228:	if (req->status || req->length != req->actual ||
file_storage.c:1229:			req->actual < 6 || req->actual > MAX_COMMAND_SIZE) {
file_storage.c:1232:		 * receiving control-out data, but we'll try anyway. */
file_storage.c:1233:		fsg_set_halt(fsg, fsg->ep0);
file_storage.c:1238:	if (req->actual >= sizeof cbi_reset_cmnd &&
file_storage.c:1239:			memcmp(req->buf, cbi_reset_cmnd,
file_storage.c:1249:	VDBG(fsg, "CB[I] accept device-specific command\n");
file_storage.c:1250:	spin_lock(&fsg->lock);
file_storage.c:1253:	if (fsg->cbbuf_cmnd_size)
file_storage.c:1255:	fsg->cbbuf_cmnd_size = req->actual;
file_storage.c:1256:	memcpy(fsg->cbbuf_cmnd, req->buf, fsg->cbbuf_cmnd_size);
file_storage.c:1258:	spin_unlock(&fsg->lock);
file_storage.c:1271:	struct usb_request	*req = fsg->ep0req;
file_storage.c:1272:	int			value = -EOPNOTSUPP;
file_storage.c:1274:	if (!fsg->config)
file_storage.c:1277:	/* Handle Bulk-only class-specific requests */
file_storage.c:1279:		switch (ctrl->bRequest) {
file_storage.c:1282:			if (ctrl->bRequestType != (USB_DIR_OUT |
file_storage.c:1285:			if (ctrl->wIndex != 0) {
file_storage.c:1286:				value = -EDOM;
file_storage.c:1298:			if (ctrl->bRequestType != (USB_DIR_IN |
file_storage.c:1301:			if (ctrl->wIndex != 0) {
file_storage.c:1302:				value = -EDOM;
file_storage.c:1306:			*(u8 *) req->buf = fsg->nluns - 1;
file_storage.c:1307:			value = min(ctrl->wLength, (u16) 1);
file_storage.c:1312:	/* Handle CBI class-specific requests */
file_storage.c:1314:		switch (ctrl->bRequest) {
file_storage.c:1317:			if (ctrl->bRequestType != (USB_DIR_OUT |
file_storage.c:1320:			if (ctrl->wIndex != 0) {
file_storage.c:1321:				value = -EDOM;
file_storage.c:1324:			if (ctrl->wLength > MAX_COMMAND_SIZE) {
file_storage.c:1325:				value = -EOVERFLOW;
file_storage.c:1328:			value = ctrl->wLength;
file_storage.c:1329:			fsg->ep0req->context = received_cbi_adsc;
file_storage.c:1334:	if (value == -EOPNOTSUPP)
file_storage.c:1336:			"unknown class-specific control req "
file_storage.c:1338:			ctrl->bRequestType, ctrl->bRequest,
file_storage.c:1339:			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
file_storage.c:1344:/*-------------------------------------------------------------------------*/
file_storage.c:1351:	struct usb_request	*req = fsg->ep0req;
file_storage.c:1352:	int			value = -EOPNOTSUPP;
file_storage.c:1354:	/* Usually this just stores reply data in the pre-allocated ep0 buffer,
file_storage.c:1356:	switch (ctrl->bRequest) {
file_storage.c:1359:		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
file_storage.c:1362:		switch (ctrl->wValue >> 8) {
file_storage.c:1366:			value = min(ctrl->wLength, (u16) sizeof device_desc);
file_storage.c:1367:			memcpy(req->buf, &device_desc, value);
file_storage.c:1372:			if (!fsg->gadget->is_dualspeed)
file_storage.c:1374:			value = min(ctrl->wLength, (u16) sizeof dev_qualifier);
file_storage.c:1375:			memcpy(req->buf, &dev_qualifier, value);
file_storage.c:1379:			VDBG(fsg, "get other-speed config descriptor\n");
file_storage.c:1380:			if (!fsg->gadget->is_dualspeed)
file_storage.c:1389:			value = populate_config_buf(fsg->gadget,
file_storage.c:1390:					req->buf,
file_storage.c:1391:					ctrl->wValue >> 8,
file_storage.c:1392:					ctrl->wValue & 0xff);
file_storage.c:1394:				value = min(ctrl->wLength, (u16) value);
file_storage.c:1402:					ctrl->wValue & 0xff, req->buf);
file_storage.c:1404:				value = min(ctrl->wLength, (u16) value);
file_storage.c:1411:		if (ctrl->bRequestType != (USB_DIR_OUT | USB_TYPE_STANDARD |
file_storage.c:1415:		if (ctrl->wValue == CONFIG_VALUE || ctrl->wValue == 0) {
file_storage.c:1416:			fsg->new_config = ctrl->wValue;
file_storage.c:1425:		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
file_storage.c:1429:		*(u8 *) req->buf = fsg->config;
file_storage.c:1430:		value = min(ctrl->wLength, (u16) 1);
file_storage.c:1434:		if (ctrl->bRequestType != (USB_DIR_OUT| USB_TYPE_STANDARD |
file_storage.c:1437:		if (fsg->config && ctrl->wIndex == 0) {
file_storage.c:1447:		if (ctrl->bRequestType != (USB_DIR_IN | USB_TYPE_STANDARD |
file_storage.c:1450:		if (!fsg->config)
file_storage.c:1452:		if (ctrl->wIndex != 0) {
file_storage.c:1453:			value = -EDOM;
file_storage.c:1457:		*(u8 *) req->buf = 0;
file_storage.c:1458:		value = min(ctrl->wLength, (u16) 1);
file_storage.c:1464:			ctrl->bRequestType, ctrl->bRequest,
file_storage.c:1465:			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
file_storage.c:1478:	++fsg->ep0_req_tag;		// Record arrival of a new request
file_storage.c:1479:	fsg->ep0req->context = NULL;
file_storage.c:1480:	fsg->ep0req->length = 0;
file_storage.c:1481:	dump_msg(fsg, "ep0-setup", (u8 *) ctrl, sizeof(*ctrl));
file_storage.c:1483:	if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_CLASS)
file_storage.c:1490:		fsg->ep0req->length = rc;
file_storage.c:1491:		fsg->ep0req->zero = (rc < ctrl->wLength &&
file_storage.c:1492:				(rc % gadget->ep0->maxpacket) == 0);
file_storage.c:1493:		fsg->ep0req_name = (ctrl->bRequestType & USB_DIR_IN ?
file_storage.c:1494:				"ep0-in" : "ep0-out");
file_storage.c:1503:/*-------------------------------------------------------------------------*/
file_storage.c:1515:	if (ep == fsg->bulk_in)
file_storage.c:1516:		dump_msg(fsg, "bulk-in", req->buf, req->length);
file_storage.c:1517:	else if (ep == fsg->intr_in)
file_storage.c:1518:		dump_msg(fsg, "intr-in", req->buf, req->length);
file_storage.c:1528:		/* Note: currently the net2280 driver fails zero-length
file_storage.c:1530:		if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP &&
file_storage.c:1531:						req->length == 0))
file_storage.c:1532:			WARN(fsg, "error in submission: %s --> %d\n",
file_storage.c:1533:					ep->name, rc);
file_storage.c:1543:	rc = wait_event_interruptible(fsg->thread_wqh,
file_storage.c:1544:			fsg->thread_wakeup_needed);
file_storage.c:1545:	fsg->thread_wakeup_needed = 0;
file_storage.c:1546:	if (current->flags & PF_FREEZE)
file_storage.c:1548:	return (rc ? -EINTR : 0);
file_storage.c:1552:/*-------------------------------------------------------------------------*/
file_storage.c:1556:	struct lun		*curlun = fsg->curlun;
file_storage.c:1568:	if (fsg->cmnd[0] == SC_READ_6)
file_storage.c:1569:		lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]);
file_storage.c:1571:		lba = get_be32(&fsg->cmnd[2]);
file_storage.c:1576:		if ((fsg->cmnd[1] & ~0x18) != 0) {
file_storage.c:1577:			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:1578:			return -EINVAL;
file_storage.c:1581:	if (lba >= curlun->num_sectors) {
file_storage.c:1582:		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
file_storage.c:1583:		return -EINVAL;
file_storage.c:1588:	amount_left = fsg->data_size_from_cmnd;
file_storage.c:1590:		return -EIO;		// No default reply
file_storage.c:1604:				curlun->file_length - file_offset);
file_storage.c:1605:		partial_page = file_offset & (PAGE_CACHE_SIZE - 1);
file_storage.c:1607:			amount = min(amount, (unsigned int) PAGE_CACHE_SIZE -
file_storage.c:1611:		bh = fsg->next_buffhd_to_fill;
file_storage.c:1612:		while (bh->state != BUF_STATE_EMPTY) {
file_storage.c:1620:			curlun->sense_data =
file_storage.c:1622:			curlun->sense_data_info = file_offset >> 9;
file_storage.c:1623:			bh->inreq->length = 0;
file_storage.c:1624:			bh->state = BUF_STATE_FULL;
file_storage.c:1630:		nread = vfs_read(curlun->filp,
file_storage.c:1631:				(char __user *) bh->buf,
file_storage.c:1633:		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
file_storage.c:1637:			return -EINTR;
file_storage.c:1646:			nread -= (nread & 511);	// Round down to a block
file_storage.c:1649:		amount_left  -= nread;
file_storage.c:1650:		fsg->residue -= nread;
file_storage.c:1651:		bh->inreq->length = nread;
file_storage.c:1652:		bh->state = BUF_STATE_FULL;
file_storage.c:1656:			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
file_storage.c:1657:			curlun->sense_data_info = file_offset >> 9;
file_storage.c:1665:		bh->inreq->zero = 0;
file_storage.c:1666:		start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:1667:				&bh->inreq_busy, &bh->state);
file_storage.c:1668:		fsg->next_buffhd_to_fill = bh->next;
file_storage.c:1671:	return -EIO;		// No default reply
file_storage.c:1675:/*-------------------------------------------------------------------------*/
file_storage.c:1679:	struct lun		*curlun = fsg->curlun;
file_storage.c:1690:	if (curlun->ro) {
file_storage.c:1691:		curlun->sense_data = SS_WRITE_PROTECTED;
file_storage.c:1692:		return -EINVAL;
file_storage.c:1694:	curlun->filp->f_flags &= ~O_SYNC;	// Default is not to wait
file_storage.c:1698:	if (fsg->cmnd[0] == SC_WRITE_6)
file_storage.c:1699:		lba = (fsg->cmnd[1] << 16) | get_be16(&fsg->cmnd[2]);
file_storage.c:1701:		lba = get_be32(&fsg->cmnd[2]);
file_storage.c:1707:		if ((fsg->cmnd[1] & ~0x18) != 0) {
file_storage.c:1708:			curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:1709:			return -EINVAL;
file_storage.c:1711:		if (fsg->cmnd[1] & 0x08)	// FUA
file_storage.c:1712:			curlun->filp->f_flags |= O_SYNC;
file_storage.c:1714:	if (lba >= curlun->num_sectors) {
file_storage.c:1715:		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
file_storage.c:1716:		return -EINVAL;
file_storage.c:1722:	amount_left_to_req = amount_left_to_write = fsg->data_size_from_cmnd;
file_storage.c:1727:		bh = fsg->next_buffhd_to_fill;
file_storage.c:1728:		if (bh->state == BUF_STATE_EMPTY && get_some_more) {
file_storage.c:1740:			amount = min((loff_t) amount, curlun->file_length -
file_storage.c:1742:			partial_page = usb_offset & (PAGE_CACHE_SIZE - 1);
file_storage.c:1745:	(unsigned int) PAGE_CACHE_SIZE - partial_page);
file_storage.c:1749:				curlun->sense_data =
file_storage.c:1751:				curlun->sense_data_info = usb_offset >> 9;
file_storage.c:1754:			amount -= (amount & 511);
file_storage.c:1765:			fsg->usb_amount_left -= amount;
file_storage.c:1766:			amount_left_to_req -= amount;
file_storage.c:1771:			 * the bulk-out maxpacket size */
file_storage.c:1772:			bh->outreq->length = bh->bulk_out_intended_length =
file_storage.c:1774:			start_transfer(fsg, fsg->bulk_out, bh->outreq,
file_storage.c:1775:					&bh->outreq_busy, &bh->state);
file_storage.c:1776:			fsg->next_buffhd_to_fill = bh->next;
file_storage.c:1781:		bh = fsg->next_buffhd_to_drain;
file_storage.c:1782:		if (bh->state == BUF_STATE_EMPTY && !get_some_more)
file_storage.c:1784:		if (bh->state == BUF_STATE_FULL) {
file_storage.c:1785:			fsg->next_buffhd_to_drain = bh->next;
file_storage.c:1786:			bh->state = BUF_STATE_EMPTY;
file_storage.c:1789:			if (bh->outreq->status != 0) {
file_storage.c:1790:				curlun->sense_data = SS_COMMUNICATION_FAILURE;
file_storage.c:1791:				curlun->sense_data_info = file_offset >> 9;
file_storage.c:1795:			amount = bh->outreq->actual;
file_storage.c:1796:			if (curlun->file_length - file_offset < amount) {
file_storage.c:1800:	(unsigned long long) curlun->file_length);
file_storage.c:1801:				amount = curlun->file_length - file_offset;
file_storage.c:1806:			nwritten = vfs_write(curlun->filp,
file_storage.c:1807:					(char __user *) bh->buf,
file_storage.c:1809:			VLDBG(curlun, "file write %u @ %llu -> %d\n", amount,
file_storage.c:1813:				return -EINTR;		// Interrupted!
file_storage.c:1822:				nwritten -= (nwritten & 511);
file_storage.c:1826:			amount_left_to_write -= nwritten;
file_storage.c:1827:			fsg->residue -= nwritten;
file_storage.c:1831:				curlun->sense_data = SS_WRITE_ERROR;
file_storage.c:1832:				curlun->sense_data_info = file_offset >> 9;
file_storage.c:1837:			if (bh->outreq->actual != bh->outreq->length) {
file_storage.c:1838:				fsg->short_packet_received = 1;
file_storage.c:1849:	return -EIO;		// No default reply
file_storage.c:1853:/*-------------------------------------------------------------------------*/
file_storage.c:1859:	struct file	*filp = curlun->filp;
file_storage.c:1863:	if (curlun->ro || !filp)
file_storage.c:1865:	if (!filp->f_op->fsync)
file_storage.c:1866:		return -EINVAL;
file_storage.c:1868:	inode = filp->f_dentry->d_inode;
file_storage.c:1869:	down(&inode->i_sem);
file_storage.c:1870:	current->flags |= PF_SYNCWRITE;
file_storage.c:1871:	rc = filemap_fdatawrite(inode->i_mapping);
file_storage.c:1872:	err = filp->f_op->fsync(filp, filp->f_dentry, 1);
file_storage.c:1875:	err = filemap_fdatawait(inode->i_mapping);
file_storage.c:1878:	current->flags &= ~PF_SYNCWRITE;
file_storage.c:1879:	up(&inode->i_sem);
file_storage.c:1880:	VLDBG(curlun, "fdatasync -> %d\n", rc);
file_storage.c:1888:	for (i = 0; i < fsg->nluns; ++i)
file_storage.c:1889:		fsync_sub(&fsg->luns[i]);
file_storage.c:1894:	struct lun	*curlun = fsg->curlun;
file_storage.c:1901:		curlun->sense_data = SS_WRITE_ERROR;
file_storage.c:1906:/*-------------------------------------------------------------------------*/
file_storage.c:1910:	struct file	*filp = curlun->filp;
file_storage.c:1911:	struct inode	*inode = filp->f_dentry->d_inode;
file_storage.c:1914:	rc = invalidate_inode_pages(inode->i_mapping);
file_storage.c:1915:	VLDBG(curlun, "invalidate_inode_pages -> %ld\n", rc);
file_storage.c:1920:	struct lun		*curlun = fsg->curlun;
file_storage.c:1923:	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
file_storage.c:1931:	lba = get_be32(&fsg->cmnd[2]);
file_storage.c:1932:	if (lba >= curlun->num_sectors) {
file_storage.c:1933:		curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
file_storage.c:1934:		return -EINVAL;
file_storage.c:1939:	if ((fsg->cmnd[1] & ~0x10) != 0) {
file_storage.c:1940:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:1941:		return -EINVAL;
file_storage.c:1944:	verification_length = get_be16(&fsg->cmnd[7]);
file_storage.c:1946:		return -EIO;		// No default reply
file_storage.c:1955:		return -EINTR;
file_storage.c:1959:		return -EINTR;
file_storage.c:1972:				curlun->file_length - file_offset);
file_storage.c:1974:			curlun->sense_data =
file_storage.c:1976:			curlun->sense_data_info = file_offset >> 9;
file_storage.c:1982:		nread = vfs_read(curlun->filp,
file_storage.c:1983:				(char __user *) bh->buf,
file_storage.c:1985:		VLDBG(curlun, "file read %u @ %llu -> %d\n", amount,
file_storage.c:1989:			return -EINTR;
file_storage.c:1998:			nread -= (nread & 511);	// Round down to a sector
file_storage.c:2001:			curlun->sense_data = SS_UNRECOVERED_READ_ERROR;
file_storage.c:2002:			curlun->sense_data_info = file_offset >> 9;
file_storage.c:2006:		amount_left -= nread;
file_storage.c:2012:/*-------------------------------------------------------------------------*/
file_storage.c:2016:	u8	*buf = (u8 *) bh->buf;
file_storage.c:2019:	static char product_id[] = "File-Stor Gadget";
file_storage.c:2021:	if (!fsg->curlun) {		// Unsupported LUNs are okay
file_storage.c:2022:		fsg->bad_lun_okay = 1;
file_storage.c:2024:		buf[0] = 0x7f;		// Unsupported, no device-type
file_storage.c:2028:	memset(buf, 0, 8);	// Non-removable, direct-access device
file_storage.c:2032:	buf[3] = 2;		// SCSI-2 INQUIRY data format
file_storage.c:2035:	sprintf(buf + 8, "%-8s%-16s%04x", vendor_id, product_id,
file_storage.c:2043:	struct lun	*curlun = fsg->curlun;
file_storage.c:2044:	u8		*buf = (u8 *) bh->buf;
file_storage.c:2048:	 * From the SCSI-2 spec., section 7.9 (Unit attention condition):
file_storage.c:2063:	if (curlun && curlun->unit_attention_data != SS_NO_SENSE) {
file_storage.c:2064:		curlun->sense_data = curlun->unit_attention_data;
file_storage.c:2065:		curlun->unit_attention_data = SS_NO_SENSE;
file_storage.c:2070:		fsg->bad_lun_okay = 1;
file_storage.c:2074:		sd = curlun->sense_data;
file_storage.c:2075:		sdinfo = curlun->sense_data_info;
file_storage.c:2076:		curlun->sense_data = SS_NO_SENSE;
file_storage.c:2077:		curlun->sense_data_info = 0;
file_storage.c:2084:	buf[7] = 18 - 8;			// Additional sense length
file_storage.c:2093:	struct lun	*curlun = fsg->curlun;
file_storage.c:2094:	u32		lba = get_be32(&fsg->cmnd[2]);
file_storage.c:2095:	int		pmi = fsg->cmnd[8];
file_storage.c:2096:	u8		*buf = (u8 *) bh->buf;
file_storage.c:2100:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2101:		return -EINVAL;
file_storage.c:2104:	put_be32(&buf[0], curlun->num_sectors - 1);	// Max logical block
file_storage.c:2112:	struct lun	*curlun = fsg->curlun;
file_storage.c:2113:	int		mscmnd = fsg->cmnd[0];
file_storage.c:2114:	u8		*buf = (u8 *) bh->buf;
file_storage.c:2121:	if ((fsg->cmnd[1] & ~0x08) != 0) {		// Mask away DBD
file_storage.c:2122:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2123:		return -EINVAL;
file_storage.c:2125:	pc = fsg->cmnd[2] >> 6;
file_storage.c:2126:	page_code = fsg->cmnd[2] & 0x3f;
file_storage.c:2128:		curlun->sense_data = SS_SAVING_PARAMETERS_NOT_SUPPORTED;
file_storage.c:2129:		return -EINVAL;
file_storage.c:2140:		buf[2] = (curlun->ro ? 0x80 : 0x00);		// WP, DPOFUA
file_storage.c:2144:		buf[3] = (curlun->ro ? 0x80 : 0x00);		// WP, DPOFUA
file_storage.c:2173:	len = buf - buf0;
file_storage.c:2175:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2176:		return -EINVAL;
file_storage.c:2181:		buf0[0] = len - 1;
file_storage.c:2183:		put_be16(buf0, len - 2);
file_storage.c:2190:	struct lun	*curlun = fsg->curlun;
file_storage.c:2194:		curlun->sense_data = SS_INVALID_COMMAND;
file_storage.c:2195:		return -EINVAL;
file_storage.c:2198:	// int immed = fsg->cmnd[1] & 0x01;
file_storage.c:2199:	loej = fsg->cmnd[4] & 0x02;
file_storage.c:2200:	start = fsg->cmnd[4] & 0x01;
file_storage.c:2203:	if ((fsg->cmnd[1] & ~0x01) != 0 ||		// Mask away Immed
file_storage.c:2204:			(fsg->cmnd[4] & ~0x03) != 0) {	// Mask LoEj, Start
file_storage.c:2205:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2206:		return -EINVAL;
file_storage.c:2212:		if (curlun->prevent_medium_removal) {
file_storage.c:2214:			curlun->sense_data = SS_MEDIUM_REMOVAL_PREVENTED;
file_storage.c:2215:			return -EINVAL;
file_storage.c:2218:			up_read(&fsg->filesem);
file_storage.c:2219:			down_write(&fsg->filesem);
file_storage.c:2221:			up_write(&fsg->filesem);
file_storage.c:2222:			down_read(&fsg->filesem);
file_storage.c:2229:			curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
file_storage.c:2230:			return -EINVAL;
file_storage.c:2240:	struct lun	*curlun = fsg->curlun;
file_storage.c:2244:		curlun->sense_data = SS_INVALID_COMMAND;
file_storage.c:2245:		return -EINVAL;
file_storage.c:2248:	prevent = fsg->cmnd[4] & 0x01;
file_storage.c:2249:	if ((fsg->cmnd[4] & ~0x01) != 0) {		// Mask away Prevent
file_storage.c:2250:		curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2251:		return -EINVAL;
file_storage.c:2254:	if (curlun->prevent_medium_removal && !prevent)
file_storage.c:2256:	curlun->prevent_medium_removal = prevent;
file_storage.c:2264:	struct lun	*curlun = fsg->curlun;
file_storage.c:2265:	u8		*buf = (u8 *) bh->buf;
file_storage.c:2271:	put_be32(&buf[0], curlun->num_sectors);		// Number of blocks
file_storage.c:2280:	struct lun	*curlun = fsg->curlun;
file_storage.c:2283:	curlun->sense_data = SS_INVALID_COMMAND;
file_storage.c:2284:	return -EINVAL;
file_storage.c:2288:/*-------------------------------------------------------------------------*/
file_storage.c:2294:	rc = fsg_set_halt(fsg, fsg->bulk_in);
file_storage.c:2295:	if (rc == -EAGAIN)
file_storage.c:2296:		VDBG(fsg, "delayed bulk-in endpoint halt\n");
file_storage.c:2298:		if (rc != -EAGAIN) {
file_storage.c:2299:			WARN(fsg, "usb_ep_set_halt -> %d\n", rc);
file_storage.c:2306:			return -EINTR;
file_storage.c:2307:		rc = usb_ep_set_halt(fsg->bulk_in);
file_storage.c:2314:	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
file_storage.c:2315:	u32			nkeep = bh->inreq->length;
file_storage.c:2319:	bh->state = BUF_STATE_EMPTY;		// For the first iteration
file_storage.c:2320:	fsg->usb_amount_left = nkeep + fsg->residue;
file_storage.c:2321:	while (fsg->usb_amount_left > 0) {
file_storage.c:2324:		while (bh->state != BUF_STATE_EMPTY) {
file_storage.c:2329:		nsend = min(fsg->usb_amount_left, (u32) mod_data.buflen);
file_storage.c:2330:		memset(bh->buf + nkeep, 0, nsend - nkeep);
file_storage.c:2331:		bh->inreq->length = nsend;
file_storage.c:2332:		bh->inreq->zero = 0;
file_storage.c:2333:		start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:2334:				&bh->inreq_busy, &bh->state);
file_storage.c:2335:		bh = fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2336:		fsg->usb_amount_left -= nsend;
file_storage.c:2348:	while ((bh = fsg->next_buffhd_to_drain)->state != BUF_STATE_EMPTY ||
file_storage.c:2349:			fsg->usb_amount_left > 0) {
file_storage.c:2352:		if (bh->state == BUF_STATE_FULL) {
file_storage.c:2353:			bh->state = BUF_STATE_EMPTY;
file_storage.c:2354:			fsg->next_buffhd_to_drain = bh->next;
file_storage.c:2357:			if (bh->outreq->actual != bh->outreq->length ||
file_storage.c:2358:					bh->outreq->status != 0) {
file_storage.c:2360:				return -EINTR;
file_storage.c:2366:		bh = fsg->next_buffhd_to_fill;
file_storage.c:2367:		if (bh->state == BUF_STATE_EMPTY && fsg->usb_amount_left > 0) {
file_storage.c:2368:			amount = min(fsg->usb_amount_left,
file_storage.c:2372:			 * the bulk-out maxpacket size */
file_storage.c:2373:			bh->outreq->length = bh->bulk_out_intended_length =
file_storage.c:2375:			start_transfer(fsg, fsg->bulk_out, bh->outreq,
file_storage.c:2376:					&bh->outreq_busy, &bh->state);
file_storage.c:2377:			fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2378:			fsg->usb_amount_left -= amount;
file_storage.c:2392:	struct fsg_buffhd	*bh = fsg->next_buffhd_to_fill;
file_storage.c:2395:	switch (fsg->data_dir) {
file_storage.c:2405:			fsg_set_halt(fsg, fsg->bulk_out);
file_storage.c:2412:		if (fsg->data_size == 0)
file_storage.c:2416:		else if (fsg->residue == 0) {
file_storage.c:2417:			bh->inreq->zero = 0;
file_storage.c:2418:			start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:2419:					&bh->inreq_busy, &bh->state);
file_storage.c:2420:			fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2427:		 * sense data is set), then halt the bulk-in endpoint
file_storage.c:2431:					fsg->residue == fsg->data_size &&
file_storage.c:2432:	(!fsg->curlun || fsg->curlun->sense_data != SS_NO_SENSE)) {
file_storage.c:2433:				bh->state = BUF_STATE_EMPTY;
file_storage.c:2436:				bh->inreq->zero = 1;
file_storage.c:2437:				start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:2438:						&bh->inreq_busy, &bh->state);
file_storage.c:2439:				fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2443:		/* For Bulk-only, if we're allowed to stall then send the
file_storage.c:2444:		 * short packet and halt the bulk-in endpoint.  If we can't
file_storage.c:2448:				bh->inreq->zero = 1;
file_storage.c:2449:				start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:2450:						&bh->inreq_busy, &bh->state);
file_storage.c:2451:				fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2459:	 * There may still be outstanding bulk-out requests. */
file_storage.c:2461:		if (fsg->residue == 0)
file_storage.c:2465:		else if (fsg->short_packet_received) {
file_storage.c:2467:			rc = -EINTR;
file_storage.c:2473:		 * bulk-out packets, in which case the host wouldn't see a
file_storage.c:2475:		 * clear the halt -- leading to problems later on. */
file_storage.c:2478:			fsg_set_halt(fsg, fsg->bulk_out);
file_storage.c:2480:			rc = -EINTR;
file_storage.c:2496:	struct lun		*curlun = fsg->curlun;
file_storage.c:2503:	bh = fsg->next_buffhd_to_fill;
file_storage.c:2504:	while (bh->state != BUF_STATE_EMPTY) {
file_storage.c:2510:		sd = curlun->sense_data;
file_storage.c:2511:		sdinfo = curlun->sense_data_info;
file_storage.c:2512:	} else if (fsg->bad_lun_okay)
file_storage.c:2517:	if (fsg->phase_error) {
file_storage.c:2518:		DBG(fsg, "sending phase-error status\n");
file_storage.c:2522:		DBG(fsg, "sending command-failure status\n");
file_storage.c:2530:		struct bulk_cs_wrap	*csw = (struct bulk_cs_wrap *) bh->buf;
file_storage.c:2532:		/* Store and send the Bulk-only CSW */
file_storage.c:2533:		csw->Signature = __constant_cpu_to_le32(USB_BULK_CS_SIG);
file_storage.c:2534:		csw->Tag = fsg->tag;
file_storage.c:2535:		csw->Residue = cpu_to_le32(fsg->residue);
file_storage.c:2536:		csw->Status = status;
file_storage.c:2538:		bh->inreq->length = USB_BULK_CS_WRAP_LEN;
file_storage.c:2539:		bh->inreq->zero = 0;
file_storage.c:2540:		start_transfer(fsg, fsg->bulk_in, bh->inreq,
file_storage.c:2541:				&bh->inreq_busy, &bh->state);
file_storage.c:2545:		/* Control-Bulk transport has no status phase! */
file_storage.c:2550:						bh->buf;
file_storage.c:2556:			buf->bType = ASC(sd);
file_storage.c:2557:			buf->bValue = ASCQ(sd);
file_storage.c:2559:			buf->bType = 0;
file_storage.c:2560:			buf->bValue = status;
file_storage.c:2562:		fsg->intreq->length = CBI_INTERRUPT_DATA_LEN;
file_storage.c:2564:		fsg->intr_buffhd = bh;		// Point to the right buffhd
file_storage.c:2565:		fsg->intreq->buf = bh->inreq->buf;
file_storage.c:2566:		fsg->intreq->dma = bh->inreq->dma;
file_storage.c:2567:		fsg->intreq->context = bh;
file_storage.c:2568:		start_transfer(fsg, fsg->intr_in, fsg->intreq,
file_storage.c:2569:				&fsg->intreq_busy, &bh->state);
file_storage.c:2572:	fsg->next_buffhd_to_fill = bh->next;
file_storage.c:2577:/*-------------------------------------------------------------------------*/
file_storage.c:2586:	int			lun = fsg->cmnd[1] >> 5;
file_storage.c:2599:		if (fsg->cmnd_size == 12)
file_storage.c:2607:	if (fsg->data_dir != DATA_DIR_UNKNOWN)
file_storage.c:2608:		sprintf(hdlen, ", H%c=%u", dirletter[(int) fsg->data_dir],
file_storage.c:2609:				fsg->data_size);
file_storage.c:2612:			fsg->data_size_from_cmnd, fsg->cmnd_size, hdlen);
file_storage.c:2616:	if (fsg->data_size_from_cmnd == 0)
file_storage.c:2618:	if (fsg->data_dir == DATA_DIR_UNKNOWN) {	// CB or CBI
file_storage.c:2619:		fsg->data_dir = data_dir;
file_storage.c:2620:		fsg->data_size = fsg->data_size_from_cmnd;
file_storage.c:2622:	} else {					// Bulk-only
file_storage.c:2623:		if (fsg->data_size < fsg->data_size_from_cmnd) {
file_storage.c:2628:			fsg->data_size_from_cmnd = fsg->data_size;
file_storage.c:2629:			fsg->phase_error = 1;
file_storage.c:2632:	fsg->residue = fsg->usb_amount_left = fsg->data_size;
file_storage.c:2635:	if (fsg->data_dir != data_dir && fsg->data_size_from_cmnd > 0) {
file_storage.c:2636:		fsg->phase_error = 1;
file_storage.c:2637:		return -EINVAL;
file_storage.c:2641:	if (cmnd_size != fsg->cmnd_size) {
file_storage.c:2643:		/* Special case workaround: MS-Windows issues REQUEST SENSE
file_storage.c:2644:		 * with cbw->Length == 12 (it should be 6). */
file_storage.c:2645:		if (fsg->cmnd[0] == SC_REQUEST_SENSE && fsg->cmnd_size == 12)
file_storage.c:2646:			cmnd_size = fsg->cmnd_size;
file_storage.c:2648:			fsg->phase_error = 1;
file_storage.c:2649:			return -EINVAL;
file_storage.c:2655:		if (fsg->lun != lun)
file_storage.c:2658:					fsg->lun, lun);
file_storage.c:2660:		fsg->lun = lun;		// Use LUN from the command
file_storage.c:2663:	if (fsg->lun >= 0 && fsg->lun < fsg->nluns) {
file_storage.c:2664:		fsg->curlun = curlun = &fsg->luns[fsg->lun];
file_storage.c:2665:		if (fsg->cmnd[0] != SC_REQUEST_SENSE) {
file_storage.c:2666:			curlun->sense_data = SS_NO_SENSE;
file_storage.c:2667:			curlun->sense_data_info = 0;
file_storage.c:2670:		fsg->curlun = curlun = NULL;
file_storage.c:2671:		fsg->bad_lun_okay = 0;
file_storage.c:2675:		if (fsg->cmnd[0] != SC_INQUIRY &&
file_storage.c:2676:				fsg->cmnd[0] != SC_REQUEST_SENSE) {
file_storage.c:2677:			DBG(fsg, "unsupported LUN %d\n", fsg->lun);
file_storage.c:2678:			return -EINVAL;
file_storage.c:2684:	if (curlun && curlun->unit_attention_data != SS_NO_SENSE &&
file_storage.c:2685:			fsg->cmnd[0] != SC_INQUIRY &&
file_storage.c:2686:			fsg->cmnd[0] != SC_REQUEST_SENSE) {
file_storage.c:2687:		curlun->sense_data = curlun->unit_attention_data;
file_storage.c:2688:		curlun->unit_attention_data = SS_NO_SENSE;
file_storage.c:2689:		return -EINVAL;
file_storage.c:2692:	/* Check that only command bytes listed in the mask are non-zero */
file_storage.c:2693:	fsg->cmnd[1] &= 0x1f;			// Mask away the LUN
file_storage.c:2695:		if (fsg->cmnd[i] && !(mask & (1 << i))) {
file_storage.c:2697:				curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
file_storage.c:2698:			return -EINVAL;
file_storage.c:2705:		curlun->sense_data = SS_MEDIUM_NOT_PRESENT;
file_storage.c:2706:		return -EINVAL;
file_storage.c:2717:	int			reply = -EINVAL;
file_storage.c:2724:	bh = fsg->next_buffhd_to_drain = fsg->next_buffhd_to_fill;
file_storage.c:2725:	while (bh->state != BUF_STATE_EMPTY) {
file_storage.c:2729:	fsg->phase_error = 0;
file_storage.c:2730:	fsg->short_packet_received = 0;
file_storage.c:2732:	down_read(&fsg->filesem);	// We're using the backing file
file_storage.c:2733:	switch (fsg->cmnd[0]) {
file_storage.c:2736:		fsg->data_size_from_cmnd = fsg->cmnd[4];
file_storage.c:2744:		fsg->data_size_from_cmnd = fsg->cmnd[4];
file_storage.c:2752:		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
file_storage.c:2760:		fsg->data_size_from_cmnd = fsg->cmnd[4];
file_storage.c:2768:		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
file_storage.c:2776:		fsg->data_size_from_cmnd = 0;
file_storage.c:2779:				"PREVENT-ALLOW MEDIUM REMOVAL")) == 0)
file_storage.c:2784:		i = fsg->cmnd[4];
file_storage.c:2785:		fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
file_storage.c:2793:		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9;
file_storage.c:2801:		fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9;
file_storage.c:2809:		fsg->data_size_from_cmnd = 8;
file_storage.c:2817:		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
file_storage.c:2825:		fsg->data_size_from_cmnd = fsg->cmnd[4];
file_storage.c:2833:		fsg->data_size_from_cmnd = 0;
file_storage.c:2836:				"START-STOP UNIT")) == 0)
file_storage.c:2841:		fsg->data_size_from_cmnd = 0;
file_storage.c:2849:		fsg->data_size_from_cmnd = 0;
file_storage.c:2855:	/* Although optional, this command is used by MS-Windows.  We
file_storage.c:2858:		fsg->data_size_from_cmnd = 0;
file_storage.c:2866:		i = fsg->cmnd[4];
file_storage.c:2867:		fsg->data_size_from_cmnd = (i == 0 ? 256 : i) << 9;
file_storage.c:2875:		fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]) << 9;
file_storage.c:2883:		fsg->data_size_from_cmnd = get_be32(&fsg->cmnd[6]) << 9;
file_storage.c:2901:		fsg->data_size_from_cmnd = 0;
file_storage.c:2902:		sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]);
file_storage.c:2903:		if ((reply = check_command(fsg, fsg->cmnd_size,
file_storage.c:2905:			fsg->curlun->sense_data = SS_INVALID_COMMAND;
file_storage.c:2906:			reply = -EINVAL;
file_storage.c:2910:	up_read(&fsg->filesem);
file_storage.c:2912:	if (reply == -EINTR || signal_pending(current))
file_storage.c:2913:		return -EINTR;
file_storage.c:2916:	if (reply == -EINVAL)
file_storage.c:2918:	if (reply >= 0 && fsg->data_dir == DATA_DIR_TO_HOST) {
file_storage.c:2919:		reply = min((u32) reply, fsg->data_size_from_cmnd);
file_storage.c:2920:		bh->inreq->length = reply;
file_storage.c:2921:		bh->state = BUF_STATE_FULL;
file_storage.c:2922:		fsg->residue -= reply;
file_storage.c:2929:/*-------------------------------------------------------------------------*/
file_storage.c:2933:	struct usb_request	*req = bh->outreq;
file_storage.c:2934:	struct bulk_cb_wrap	*cbw = (struct bulk_cb_wrap *) req->buf;
file_storage.c:2937:	if (req->status)
file_storage.c:2938:		return -EINVAL;
file_storage.c:2941:	if (req->actual != USB_BULK_CB_WRAP_LEN ||
file_storage.c:2942:			cbw->Signature != __constant_cpu_to_le32(
file_storage.c:2945:				req->actual,
file_storage.c:2946:				le32_to_cpu(cbw->Signature));
file_storage.c:2948:		/* The Bulk-only spec says we MUST stall the bulk pipes!
file_storage.c:2952:			set_bit(CLEAR_BULK_HALTS, &fsg->atomic_bitflags);
file_storage.c:2953:		fsg_set_halt(fsg, fsg->bulk_out);
file_storage.c:2955:		return -EINVAL;
file_storage.c:2959:	if (cbw->Lun >= MAX_LUNS || cbw->Flags & ~USB_BULK_IN_FLAG ||
file_storage.c:2960:			cbw->Length < 6 || cbw->Length > MAX_COMMAND_SIZE) {
file_storage.c:2961:		DBG(fsg, "non-meaningful CBW: lun = %u, flags = 0x%x, "
file_storage.c:2963:				cbw->Lun, cbw->Flags, cbw->Length);
file_storage.c:2968:			fsg_set_halt(fsg, fsg->bulk_out);
file_storage.c:2971:		return -EINVAL;
file_storage.c:2975:	fsg->cmnd_size = cbw->Length;
file_storage.c:2976:	memcpy(fsg->cmnd, cbw->CDB, fsg->cmnd_size);
file_storage.c:2977:	if (cbw->Flags & USB_BULK_IN_FLAG)
file_storage.c:2978:		fsg->data_dir = DATA_DIR_TO_HOST;
file_storage.c:2980:		fsg->data_dir = DATA_DIR_FROM_HOST;
file_storage.c:2981:	fsg->data_size = le32_to_cpu(cbw->DataTransferLength);
file_storage.c:2982:	if (fsg->data_size == 0)
file_storage.c:2983:		fsg->data_dir = DATA_DIR_NONE;
file_storage.c:2984:	fsg->lun = cbw->Lun;
file_storage.c:2985:	fsg->tag = cbw->Tag;
file_storage.c:2998:		bh = fsg->next_buffhd_to_fill;
file_storage.c:2999:		while (bh->state != BUF_STATE_EMPTY) {
file_storage.c:3004:		/* Queue a request to read a Bulk-only CBW */
file_storage.c:3006:		start_transfer(fsg, fsg->bulk_out, bh->outreq,
file_storage.c:3007:				&bh->outreq_busy, &bh->state);
file_storage.c:3014:		while (bh->state != BUF_STATE_FULL) {
file_storage.c:3019:		bh->state = BUF_STATE_EMPTY;
file_storage.c:3024:		while (fsg->cbbuf_cmnd_size == 0) {
file_storage.c:3032:		if (fsg->intreq_busy)
file_storage.c:3033:			usb_ep_dequeue(fsg->intr_in, fsg->intreq);
file_storage.c:3036:		fsg->data_dir = DATA_DIR_UNKNOWN;
file_storage.c:3037:		spin_lock_irq(&fsg->lock);
file_storage.c:3038:		fsg->cmnd_size = fsg->cbbuf_cmnd_size;
file_storage.c:3039:		memcpy(fsg->cmnd, fsg->cbbuf_cmnd, fsg->cmnd_size);
file_storage.c:3040:		fsg->cbbuf_cmnd_size = 0;
file_storage.c:3041:		spin_unlock_irq(&fsg->lock);
file_storage.c:3047:/*-------------------------------------------------------------------------*/
file_storage.c:3054:	ep->driver_data = fsg;
file_storage.c:3057:		ERROR(fsg, "can't enable %s, result %d\n", ep->name, rc);
file_storage.c:3067:	ERROR(fsg, "can't allocate request for %s\n", ep->name);
file_storage.c:3068:	return -ENOMEM;
file_storage.c:3072: * Reset interface setting and re-init endpoint state (toggle etc).
file_storage.c:3082:	if (fsg->running)
file_storage.c:3088:		struct fsg_buffhd *bh = &fsg->buffhds[i];
file_storage.c:3090:		if (bh->inreq) {
file_storage.c:3091:			usb_ep_free_request(fsg->bulk_in, bh->inreq);
file_storage.c:3092:			bh->inreq = NULL;
file_storage.c:3094:		if (bh->outreq) {
file_storage.c:3095:			usb_ep_free_request(fsg->bulk_out, bh->outreq);
file_storage.c:3096:			bh->outreq = NULL;
file_storage.c:3099:	if (fsg->intreq) {
file_storage.c:3100:		usb_ep_free_request(fsg->intr_in, fsg->intreq);
file_storage.c:3101:		fsg->intreq = NULL;
file_storage.c:3105:	if (fsg->bulk_in_enabled) {
file_storage.c:3106:		usb_ep_disable(fsg->bulk_in);
file_storage.c:3107:		fsg->bulk_in_enabled = 0;
file_storage.c:3109:	if (fsg->bulk_out_enabled) {
file_storage.c:3110:		usb_ep_disable(fsg->bulk_out);
file_storage.c:3111:		fsg->bulk_out_enabled = 0;
file_storage.c:3113:	if (fsg->intr_in_enabled) {
file_storage.c:3114:		usb_ep_disable(fsg->intr_in);
file_storage.c:3115:		fsg->intr_in_enabled = 0;
file_storage.c:3118:	fsg->running = 0;
file_storage.c:3125:	d = ep_desc(fsg->gadget, &fs_bulk_in_desc, &hs_bulk_in_desc);
file_storage.c:3126:	if ((rc = enable_endpoint(fsg, fsg->bulk_in, d)) != 0)
file_storage.c:3128:	fsg->bulk_in_enabled = 1;
file_storage.c:3130:	d = ep_desc(fsg->gadget, &fs_bulk_out_desc, &hs_bulk_out_desc);
file_storage.c:3131:	if ((rc = enable_endpoint(fsg, fsg->bulk_out, d)) != 0)
file_storage.c:3133:	fsg->bulk_out_enabled = 1;
file_storage.c:3134:	fsg->bulk_out_maxpacket = le16_to_cpu(d->wMaxPacketSize);
file_storage.c:3137:		d = ep_desc(fsg->gadget, &fs_intr_in_desc, &hs_intr_in_desc);
file_storage.c:3138:		if ((rc = enable_endpoint(fsg, fsg->intr_in, d)) != 0)
file_storage.c:3140:		fsg->intr_in_enabled = 1;
file_storage.c:3145:		struct fsg_buffhd	*bh = &fsg->buffhds[i];
file_storage.c:3147:		if ((rc = alloc_request(fsg, fsg->bulk_in, &bh->inreq)) != 0)
file_storage.c:3149:		if ((rc = alloc_request(fsg, fsg->bulk_out, &bh->outreq)) != 0)
file_storage.c:3151:		bh->inreq->buf = bh->outreq->buf = bh->buf;
file_storage.c:3152:		bh->inreq->dma = bh->outreq->dma = bh->dma;
file_storage.c:3153:		bh->inreq->context = bh->outreq->context = bh;
file_storage.c:3154:		bh->inreq->complete = bulk_in_complete;
file_storage.c:3155:		bh->outreq->complete = bulk_out_complete;
file_storage.c:3158:		if ((rc = alloc_request(fsg, fsg->intr_in, &fsg->intreq)) != 0)
file_storage.c:3160:		fsg->intreq->complete = intr_in_complete;
file_storage.c:3163:	fsg->running = 1;
file_storage.c:3164:	for (i = 0; i < fsg->nluns; ++i)
file_storage.c:3165:		fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
file_storage.c:3176: * For now we just assume the gadget is always self-powered.
file_storage.c:3183:	if (fsg->config != 0) {
file_storage.c:3185:		fsg->config = 0;
file_storage.c:3186:		rc = do_set_interface(fsg, -1);
file_storage.c:3191:		fsg->config = new_config;
file_storage.c:3193:			fsg->config = 0;	// Reset on errors
file_storage.c:3197:			switch (fsg->gadget->speed) {
file_storage.c:3203:			INFO(fsg, "%s speed config #%d\n", speed, fsg->config);
file_storage.c:3210:/*-------------------------------------------------------------------------*/
file_storage.c:3226:	 * into a high-priority EXIT exception. */
file_storage.c:3228:		sig = dequeue_signal_lock(current, &fsg->thread_signal_mask,
file_storage.c:3233:			if (fsg->state < FSG_STATE_EXIT)
file_storage.c:3240:	if (fsg->intreq_busy)
file_storage.c:3241:		usb_ep_dequeue(fsg->intr_in, fsg->intreq);
file_storage.c:3243:		bh = &fsg->buffhds[i];
file_storage.c:3244:		if (bh->inreq_busy)
file_storage.c:3245:			usb_ep_dequeue(fsg->bulk_in, bh->inreq);
file_storage.c:3246:		if (bh->outreq_busy)
file_storage.c:3247:			usb_ep_dequeue(fsg->bulk_out, bh->outreq);
file_storage.c:3252:		num_active = fsg->intreq_busy;
file_storage.c:3254:			bh = &fsg->buffhds[i];
file_storage.c:3255:			num_active += bh->inreq_busy + bh->outreq_busy;
file_storage.c:3264:	if (fsg->bulk_in_enabled)
file_storage.c:3265:		usb_ep_fifo_flush(fsg->bulk_in);
file_storage.c:3266:	if (fsg->bulk_out_enabled)
file_storage.c:3267:		usb_ep_fifo_flush(fsg->bulk_out);
file_storage.c:3268:	if (fsg->intr_in_enabled)
file_storage.c:3269:		usb_ep_fifo_flush(fsg->intr_in);
file_storage.c:3273:	spin_lock_irq(&fsg->lock);
file_storage.c:3276:		bh = &fsg->buffhds[i];
file_storage.c:3277:		bh->state = BUF_STATE_EMPTY;
file_storage.c:3279:	fsg->next_buffhd_to_fill = fsg->next_buffhd_to_drain =
file_storage.c:3280:			&fsg->buffhds[0];
file_storage.c:3282:	exception_req_tag = fsg->exception_req_tag;
file_storage.c:3283:	new_config = fsg->new_config;
file_storage.c:3284:	old_state = fsg->state;
file_storage.c:3287:		fsg->state = FSG_STATE_STATUS_PHASE;
file_storage.c:3289:		for (i = 0; i < fsg->nluns; ++i) {
file_storage.c:3290:			curlun = &fsg->luns[i];
file_storage.c:3291:			curlun->prevent_medium_removal = 0;
file_storage.c:3292:			curlun->sense_data = curlun->unit_attention_data =
file_storage.c:3294:			curlun->sense_data_info = 0;
file_storage.c:3296:		fsg->state = FSG_STATE_IDLE;
file_storage.c:3298:	spin_unlock_irq(&fsg->lock);
file_storage.c:3307:		spin_lock_irq(&fsg->lock);
file_storage.c:3308:		if (fsg->state == FSG_STATE_STATUS_PHASE)
file_storage.c:3309:			fsg->state = FSG_STATE_IDLE;
file_storage.c:3310:		spin_unlock_irq(&fsg->lock);
file_storage.c:3318:				&fsg->atomic_bitflags)) {
file_storage.c:3319:			usb_ep_clear_halt(fsg->bulk_in);
file_storage.c:3320:			usb_ep_clear_halt(fsg->bulk_out);
file_storage.c:3324:			if (fsg->ep0_req_tag == exception_req_tag)
file_storage.c:3333:		// for (i = 0; i < fsg->nluns; ++i)
file_storage.c:3334:		//	fsg->luns[i].unit_attention_data = SS_RESET_OCCURRED;
file_storage.c:3339:		if (fsg->ep0_req_tag != exception_req_tag)
file_storage.c:3342:			fsg_set_halt(fsg, fsg->ep0);
file_storage.c:3349:		if (fsg->ep0_req_tag != exception_req_tag)
file_storage.c:3352:			fsg_set_halt(fsg, fsg->ep0);
file_storage.c:3365:		spin_lock_irq(&fsg->lock);
file_storage.c:3366:		fsg->state = FSG_STATE_TERMINATED;	// Stop the thread
file_storage.c:3367:		spin_unlock_irq(&fsg->lock);
file_storage.c:3373:/*-------------------------------------------------------------------------*/
file_storage.c:3379:	fsg->thread_task = current;
file_storage.c:3382:	daemonize("file-storage-gadget");
file_storage.c:3386:	siginitsetinv(&fsg->thread_signal_mask, sigmask(SIGINT) |
file_storage.c:3389:	sigprocmask(SIG_SETMASK, &fsg->thread_signal_mask, NULL);
file_storage.c:3397:	wait_for_completion(&fsg->thread_notifier);
file_storage.c:3400:	while (fsg->state != FSG_STATE_TERMINATED) {
file_storage.c:3406:		if (!fsg->running) {
file_storage.c:3414:		spin_lock_irq(&fsg->lock);
file_storage.c:3416:			fsg->state = FSG_STATE_DATA_PHASE;
file_storage.c:3417:		spin_unlock_irq(&fsg->lock);
file_storage.c:3422:		spin_lock_irq(&fsg->lock);
file_storage.c:3424:			fsg->state = FSG_STATE_STATUS_PHASE;
file_storage.c:3425:		spin_unlock_irq(&fsg->lock);
file_storage.c:3430:		spin_lock_irq(&fsg->lock);
file_storage.c:3432:			fsg->state = FSG_STATE_IDLE;
file_storage.c:3433:		spin_unlock_irq(&fsg->lock);
file_storage.c:3436:	fsg->thread_task = NULL;
file_storage.c:3441:	if (test_and_clear_bit(REGISTERED, &fsg->atomic_bitflags)) {
file_storage.c:3447:	complete_and_exit(&fsg->thread_notifier, 0);
file_storage.c:3451:/*-------------------------------------------------------------------------*/
file_storage.c:3454: * the caller must own fsg->filesem for writing. */
file_storage.c:3460:	int				rc = -EINVAL;
file_storage.c:3466:	ro = curlun->ro;
file_storage.c:3469:		if (-EROFS == PTR_ERR(filp))
file_storage.c:3479:	if (!(filp->f_mode & FMODE_WRITE))
file_storage.c:3482:	if (filp->f_dentry)
file_storage.c:3483:		inode = filp->f_dentry->d_inode;
file_storage.c:3484:	if (inode && S_ISBLK(inode->i_mode)) {
file_storage.c:3485:		if (bdev_read_only(inode->i_bdev))
file_storage.c:3487:	} else if (!inode || !S_ISREG(inode->i_mode)) {
file_storage.c:3493:	 * If we can't write the file, use it read-only. */
file_storage.c:3494:	if (!filp->f_op || !(filp->f_op->read || filp->f_op->aio_read)) {
file_storage.c:3498:	if (!(filp->f_op->write || filp->f_op->aio_write))
file_storage.c:3501:	size = i_size_read(inode->i_mapping->host);
file_storage.c:3507:	num_sectors = size >> 9;	// File size in 512-byte sectors
file_storage.c:3510:		rc = -ETOOSMALL;
file_storage.c:3515:	curlun->ro = ro;
file_storage.c:3516:	curlun->filp = filp;
file_storage.c:3517:	curlun->file_length = size;
file_storage.c:3518:	curlun->num_sectors = num_sectors;
file_storage.c:3523:	filp_close(filp, current->files);
file_storage.c:3530:	if (curlun->filp) {
file_storage.c:3532:		fput(curlun->filp);
file_storage.c:3533:		curlun->filp = NULL;
file_storage.c:3541:	for (i = 0; i < fsg->nluns; ++i)
file_storage.c:3542:		close_backing_file(&fsg->luns[i]);
file_storage.c:3550:	return sprintf(buf, "%d\n", curlun->ro);
file_storage.c:3560:	down_read(&fsg->filesem);
file_storage.c:3562:		p = d_path(curlun->filp->f_dentry, curlun->filp->f_vfsmnt,
file_storage.c:3563:				buf, PAGE_SIZE - 1);
file_storage.c:3576:	up_read(&fsg->filesem);
file_storage.c:3589:		return -EINVAL;
file_storage.c:3591:	/* Allow the write-enable status to change only while the backing file
file_storage.c:3593:	down_read(&fsg->filesem);
file_storage.c:3595:		LDBG(curlun, "read-only status change prevented\n");
file_storage.c:3596:		rc = -EBUSY;
file_storage.c:3598:		curlun->ro = !!i;
file_storage.c:3599:		LDBG(curlun, "read-only status set to %d\n", curlun->ro);
file_storage.c:3601:	up_read(&fsg->filesem);
file_storage.c:3611:	if (curlun->prevent_medium_removal && backing_file_is_open(curlun)) {
file_storage.c:3613:		return -EBUSY;				// "Door is locked"
file_storage.c:3617:	if (count > 0 && buf[count-1] == '\n')
file_storage.c:3618:		((char *) buf)[count-1] = 0;		// Ugh!
file_storage.c:3621:	down_write(&fsg->filesem);
file_storage.c:3624:		curlun->unit_attention_data = SS_MEDIUM_NOT_PRESENT;
file_storage.c:3631:			curlun->unit_attention_data =
file_storage.c:3634:	up_write(&fsg->filesem);
file_storage.c:3644:/*-------------------------------------------------------------------------*/
file_storage.c:3650:	complete(&fsg->lun_released);
file_storage.c:3658:	struct usb_request	*req = fsg->ep0req;
file_storage.c:3661:	clear_bit(REGISTERED, &fsg->atomic_bitflags);
file_storage.c:3664:	init_completion(&fsg->lun_released);
file_storage.c:3665:	for (i = 0; i < fsg->nluns; ++i) {
file_storage.c:3666:		curlun = &fsg->luns[i];
file_storage.c:3667:		if (curlun->registered) {
file_storage.c:3668:			device_remove_file(&curlun->dev, &dev_attr_ro);
file_storage.c:3669:			device_remove_file(&curlun->dev, &dev_attr_file);
file_storage.c:3670:			device_unregister(&curlun->dev);
file_storage.c:3671:			wait_for_completion(&fsg->lun_released);
file_storage.c:3672:			curlun->registered = 0;
file_storage.c:3677:	if (fsg->state != FSG_STATE_TERMINATED) {
file_storage.c:3679:		wait_for_completion(&fsg->thread_notifier);
file_storage.c:3682:		complete(&fsg->thread_notifier);
file_storage.c:3687:		struct fsg_buffhd	*bh = &fsg->buffhds[i];
file_storage.c:3689:		if (bh->buf)
file_storage.c:3690:			usb_ep_free_buffer(fsg->bulk_in, bh->buf, bh->dma,
file_storage.c:3696:		if (req->buf)
file_storage.c:3697:			usb_ep_free_buffer(fsg->ep0, req->buf,
file_storage.c:3698:					req->dma, EP0_BUFSIZE);
file_storage.c:3699:		usb_ep_free_request(fsg->ep0, req);
file_storage.c:3712:	mod_data.transport_name = "Bulk-only";
file_storage.c:3716:	if (gadget_is_sh(fsg->gadget))
file_storage.c:3720:		if (gadget_is_net2280(fsg->gadget))
file_storage.c:3722:		else if (gadget_is_dummy(fsg->gadget))
file_storage.c:3724:		else if (gadget_is_pxa(fsg->gadget))
file_storage.c:3726:		else if (gadget_is_sh(fsg->gadget))
file_storage.c:3731:		else if (gadget_is_goku(fsg->gadget))
file_storage.c:3733:		else if (gadget_is_mq11xx(fsg->gadget))
file_storage.c:3735:		else if (gadget_is_omap(fsg->gadget))
file_storage.c:3737:		else if (gadget_is_lh7a40x(fsg->gadget))
file_storage.c:3739:		else if (gadget_is_n9604(fsg->gadget))
file_storage.c:3741:		else if (gadget_is_pxa27x(fsg->gadget))
file_storage.c:3745:				fsg->gadget->name);
file_storage.c:3757:		mod_data.transport_name = "Control-Bulk";
file_storage.c:3760:		mod_data.transport_name = "Control-Bulk-Interrupt";
file_storage.c:3763:		return -EINVAL;
file_storage.c:3781:		mod_data.protocol_name = "QIC-157";
file_storage.c:3792:		return -EINVAL;
file_storage.c:3798:		return -ETOOSMALL;
file_storage.c:3816:	fsg->gadget = gadget;
file_storage.c:3818:	fsg->ep0 = gadget->ep0;
file_storage.c:3819:	fsg->ep0->driver_data = fsg;
file_storage.c:3836:		rc = -EINVAL;
file_storage.c:3842:	fsg->luns = kmalloc(i * sizeof(struct lun), GFP_KERNEL);
file_storage.c:3843:	if (!fsg->luns) {
file_storage.c:3844:		rc = -ENOMEM;
file_storage.c:3847:	memset(fsg->luns, 0, i * sizeof(struct lun));
file_storage.c:3848:	fsg->nluns = i;
file_storage.c:3850:	for (i = 0; i < fsg->nluns; ++i) {
file_storage.c:3851:		curlun = &fsg->luns[i];
file_storage.c:3852:		curlun->ro = ro[i];
file_storage.c:3853:		curlun->dev.parent = &gadget->dev;
file_storage.c:3854:		curlun->dev.driver = &fsg_driver.driver;
file_storage.c:3855:		dev_set_drvdata(&curlun->dev, fsg);
file_storage.c:3856:		snprintf(curlun->dev.bus_id, BUS_ID_SIZE,
file_storage.c:3857:				"%s-lun%d", gadget->dev.bus_id, i);
file_storage.c:3859:		if ((rc = device_register(&curlun->dev)) != 0)
file_storage.c:3862:			curlun->registered = 1;
file_storage.c:3863:			curlun->dev.release = lun_release;
file_storage.c:3864:			device_create_file(&curlun->dev, &dev_attr_ro);
file_storage.c:3865:			device_create_file(&curlun->dev, &dev_attr_file);
file_storage.c:3873:			rc = -EINVAL;
file_storage.c:3883:	ep->driver_data = fsg;		// claim the endpoint
file_storage.c:3884:	fsg->bulk_in = ep;
file_storage.c:3889:	ep->driver_data = fsg;		// claim the endpoint
file_storage.c:3890:	fsg->bulk_out = ep;
file_storage.c:3896:		ep->driver_data = fsg;		// claim the endpoint
file_storage.c:3897:		fsg->intr_in = ep;
file_storage.c:3901:	device_desc.bMaxPacketSize0 = fsg->ep0->maxpacket;
file_storage.c:3916:	dev_qualifier.bMaxPacketSize0 = fsg->ep0->maxpacket;
file_storage.c:3924:	if (gadget->is_otg) {
file_storage.c:3929:	rc = -ENOMEM;
file_storage.c:3932:	fsg->ep0req = req = usb_ep_alloc_request(fsg->ep0, GFP_KERNEL);
file_storage.c:3935:	req->buf = usb_ep_alloc_buffer(fsg->ep0, EP0_BUFSIZE,
file_storage.c:3936:			&req->dma, GFP_KERNEL);
file_storage.c:3937:	if (!req->buf)
file_storage.c:3939:	req->complete = ep0_complete;
file_storage.c:3943:		struct fsg_buffhd	*bh = &fsg->buffhds[i];
file_storage.c:3945:		bh->buf = usb_ep_alloc_buffer(fsg->bulk_in, mod_data.buflen,
file_storage.c:3946:				&bh->dma, GFP_KERNEL);
file_storage.c:3947:		if (!bh->buf)
file_storage.c:3949:		bh->next = bh + 1;
file_storage.c:3951:	fsg->buffhds[NUM_BUFFERS - 1].next = &fsg->buffhds[0];
file_storage.c:3958:			gadget->name);
file_storage.c:3962:	for (i = 0; i < sizeof(serial) - 2; i += 2) {
file_storage.c:3973:	fsg->thread_pid = rc;
file_storage.c:3976:	INFO(fsg, "Number of LUNs=%d\n", fsg->nluns);
file_storage.c:3979:	for (i = 0; i < fsg->nluns; ++i) {
file_storage.c:3980:		curlun = &fsg->luns[i];
file_storage.c:3984:				p = d_path(curlun->filp->f_dentry,
file_storage.c:3985:					curlun->filp->f_vfsmnt,
file_storage.c:3991:					curlun->ro, (p ? p : "(error)"));
file_storage.c:4005:	DBG(fsg, "I/O thread pid: %d\n", fsg->thread_pid);
file_storage.c:4010:	rc = -ENOTSUPP;
file_storage.c:4013:	fsg->state = FSG_STATE_TERMINATED;	// The thread is dead
file_storage.c:4020:/*-------------------------------------------------------------------------*/
file_storage.c:4027:	set_bit(SUSPENDED, &fsg->atomic_bitflags);
file_storage.c:4035:	clear_bit(SUSPENDED, &fsg->atomic_bitflags);
file_storage.c:4039:/*-------------------------------------------------------------------------*/
file_storage.c:4070:		return -ENOMEM;
file_storage.c:4072:	spin_lock_init(&fsg->lock);
file_storage.c:4073:	init_rwsem(&fsg->filesem);
file_storage.c:4074:	init_waitqueue_head(&fsg->thread_wqh);
file_storage.c:4075:	init_completion(&fsg->thread_notifier);
file_storage.c:4084:	kfree(fsg->luns);
file_storage.c:4101:	set_bit(REGISTERED, &fsg->atomic_bitflags);
file_storage.c:4104:	complete(&fsg->thread_notifier);
file_storage.c:4115:	if (test_and_clear_bit(REGISTERED, &fsg->atomic_bitflags))
file_storage.c:4119:	wait_for_completion(&fsg->thread_notifier);
goku_udc.c:2: * Toshiba TC86C001 ("Goku-S") USB Device Controller driver
goku_udc.c:4: * Copyright (C) 2000-2002 Lineo
goku_udc.c:15: * This device has ep0 and three semi-configurable bulk/interrupt endpoints.
goku_udc.c:17: *  - Endpoint numbering is fixed: ep{1,2,3}-bulk
goku_udc.c:18: *  - Gadget drivers can choose ep maxpacket (8/16/32/64)
goku_udc.c:19: *  - Gadget drivers can choose direction (IN, OUT)
goku_udc.c:20: *  - DMA works with ep1 (OUT transfers) and ep2 (IN transfers).
goku_udc.c:25:// #define	USB_TRACE	/* packet-level success messages */
goku_udc.c:56:#define	DRIVER_VERSION		"30-Oct 2003"
goku_udc.c:69: * IN dma behaves ok under testing, though the IN-dma abort paths don't
goku_udc.c:74: * if the OUT-dma abort problems had a resolution.
goku_udc.c:88:/*-------------------------------------------------------------------------*/
goku_udc.c:95:	writel(COMMAND_EP(epnum) | command, &regs->Command);
goku_udc.c:109:	if (!_ep || !desc || ep->desc
goku_udc.c:110:			|| desc->bDescriptorType != USB_DT_ENDPOINT)
goku_udc.c:111:		return -EINVAL;
goku_udc.c:112:	dev = ep->dev;
goku_udc.c:113:	if (ep == &dev->ep[0])
goku_udc.c:114:		return -EINVAL;
goku_udc.c:115:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
goku_udc.c:116:		return -ESHUTDOWN;
goku_udc.c:117:	if (ep->num != (desc->bEndpointAddress & 0x0f))
goku_udc.c:118:		return -EINVAL;
goku_udc.c:120:	switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
goku_udc.c:125:		return -EINVAL;
goku_udc.c:128:	if ((readl(ep->reg_status) & EPxSTATUS_EP_MASK)
goku_udc.c:130:		return -EBUSY;
goku_udc.c:132:	/* enabling the no-toggle interrupt mode would need an api hook */
goku_udc.c:134:	max = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
goku_udc.c:142:		return -EINVAL;
goku_udc.c:144:	mode |= 2 << 1;		/* bulk, or intr-with-toggle */
goku_udc.c:147:	 * direction, with pio.  be cautious with out-dma.
goku_udc.c:149:	ep->is_in = (USB_DIR_IN & desc->bEndpointAddress) != 0;
goku_udc.c:150:	if (ep->is_in) {
goku_udc.c:152:		ep->dma = (use_dma != 0) && (ep->num == UDC_MSTRD_ENDPOINT);
goku_udc.c:154:		ep->dma = (use_dma == 2) && (ep->num == UDC_MSTWR_ENDPOINT);
goku_udc.c:155:		if (ep->dma)
goku_udc.c:156:			DBG(dev, "%s out-dma hides short packets\n",
goku_udc.c:157:				ep->ep.name);
goku_udc.c:160:	spin_lock_irqsave(&ep->dev->lock, flags);
goku_udc.c:163:	if (ep->num < 3) {
goku_udc.c:164:		struct goku_udc_regs __iomem	*regs = ep->dev->regs;
goku_udc.c:168:		tmp = ((ep->dma || !ep->is_in)
goku_udc.c:171:			) << ep->num;
goku_udc.c:172:		tmp |= readl(&regs->EPxSingle);
goku_udc.c:173:		writel(tmp, &regs->EPxSingle);
goku_udc.c:175:		tmp = (ep->dma ? 0x10/*dma*/ : 0x11/*pio*/) << ep->num;
goku_udc.c:176:		tmp |= readl(&regs->EPxBCS);
goku_udc.c:177:		writel(tmp, &regs->EPxBCS);
goku_udc.c:179:	writel(mode, ep->reg_mode);
goku_udc.c:180:	command(ep->dev->regs, COMMAND_RESET, ep->num);
goku_udc.c:181:	ep->ep.maxpacket = max;
goku_udc.c:182:	ep->stopped = 0;
goku_udc.c:183:	ep->desc = desc;
goku_udc.c:184:	spin_unlock_irqrestore(&ep->dev->lock, flags);
goku_udc.c:186:	DBG(dev, "enable %s %s %s maxpacket %u\n", ep->ep.name,
goku_udc.c:187:		ep->is_in ? "IN" : "OUT",
goku_udc.c:188:		ep->dma ? "dma" : "pio",
goku_udc.c:196:	struct goku_udc		*dev = ep->dev;
goku_udc.c:199:		command(regs, COMMAND_INVALID, ep->num);
goku_udc.c:200:		if (ep->num) {
goku_udc.c:201:			if (ep->num == UDC_MSTWR_ENDPOINT)
goku_udc.c:202:				dev->int_enable &= ~(INT_MSTWREND
goku_udc.c:204:			else if (ep->num == UDC_MSTRD_ENDPOINT)
goku_udc.c:205:				dev->int_enable &= ~INT_MSTRDEND;
goku_udc.c:206:			dev->int_enable &= ~INT_EPxDATASET (ep->num);
goku_udc.c:208:			dev->int_enable &= ~INT_EP0;
goku_udc.c:209:		writel(dev->int_enable, &regs->int_enable);
goku_udc.c:210:		readl(&regs->int_enable);
goku_udc.c:211:		if (ep->num < 3) {
goku_udc.c:212:			struct goku_udc_regs __iomem	*r = ep->dev->regs;
goku_udc.c:215:			tmp = readl(&r->EPxSingle);
goku_udc.c:216:			tmp &= ~(0x11 << ep->num);
goku_udc.c:217:			writel(tmp, &r->EPxSingle);
goku_udc.c:219:			tmp = readl(&r->EPxBCS);
goku_udc.c:220:			tmp &= ~(0x11 << ep->num);
goku_udc.c:221:			writel(tmp, &r->EPxBCS);
goku_udc.c:224:		if (ep->dma) {
goku_udc.c:227:			master = readl(&regs->dma_master) & MST_RW_BITS;
goku_udc.c:228:			if (ep->num == UDC_MSTWR_ENDPOINT) {
goku_udc.c:235:			writel(master, &regs->dma_master);
goku_udc.c:239:	ep->ep.maxpacket = MAX_FIFO_SIZE;
goku_udc.c:240:	ep->desc = NULL;
goku_udc.c:241:	ep->stopped = 1;
goku_udc.c:242:	ep->irqs = 0;
goku_udc.c:243:	ep->dma = 0;
goku_udc.c:253:	if (!_ep || !ep->desc)
goku_udc.c:254:		return -ENODEV;
goku_udc.c:255:	dev = ep->dev;
goku_udc.c:256:	if (dev->ep0state == EP0_SUSPEND)
goku_udc.c:257:		return -EBUSY;
goku_udc.c:259:	VDBG(dev, "disable %s\n", _ep->name);
goku_udc.c:261:	spin_lock_irqsave(&dev->lock, flags);
goku_udc.c:262:	nuke(ep, -ESHUTDOWN);
goku_udc.c:263:	ep_reset(dev->regs, ep);
goku_udc.c:264:	spin_unlock_irqrestore(&dev->lock, flags);
goku_udc.c:269:/*-------------------------------------------------------------------------*/
goku_udc.c:283:	req->req.dma = DMA_ADDR_INVALID;
goku_udc.c:284:	INIT_LIST_HEAD(&req->queue);
goku_udc.c:285:	return &req->req;
goku_udc.c:297:	WARN_ON(!list_empty(&req->queue));
goku_udc.c:301:/*-------------------------------------------------------------------------*/
goku_udc.c:305:/* many common platforms have dma-coherent caches, which means that it's
goku_udc.c:308: * between dma and non-dma activities, which is a slow idea in any case.)
goku_udc.c:325: * on some platforms will mean eliminating a per-io buffer copy.  with
goku_udc.c:345:	if (ep->dma) {
goku_udc.c:347:		 * on typical 1/N page allocations: it allocates 1-N pages.
goku_udc.c:350:		retval = dma_alloc_coherent(&ep->dev->pdev->dev,
goku_udc.c:369:		dma_free_coherent(&ep->dev->pdev->dev, bytes, buf, dma);
goku_udc.c:375:/*-------------------------------------------------------------------------*/
goku_udc.c:381:	unsigned		stopped = ep->stopped;
goku_udc.c:383:	list_del_init(&req->queue);
goku_udc.c:385:	if (likely(req->req.status == -EINPROGRESS))
goku_udc.c:386:		req->req.status = status;
goku_udc.c:388:		status = req->req.status;
goku_udc.c:390:	dev = ep->dev;
goku_udc.c:391:	if (req->mapped) {
goku_udc.c:392:		pci_unmap_single(dev->pdev, req->req.dma, req->req.length,
goku_udc.c:393:			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
goku_udc.c:394:		req->req.dma = DMA_ADDR_INVALID;
goku_udc.c:395:		req->mapped = 0;
goku_udc.c:399:	if (status && status != -ESHUTDOWN)
goku_udc.c:402:			ep->ep.name, &req->req, status,
goku_udc.c:403:			req->req.actual, req->req.length);
goku_udc.c:406:	ep->stopped = 1;
goku_udc.c:407:	spin_unlock(&dev->lock);
goku_udc.c:408:	req->req.complete(&ep->ep, &req->req);
goku_udc.c:409:	spin_lock(&dev->lock);
goku_udc.c:410:	ep->stopped = stopped;
goku_udc.c:413:/*-------------------------------------------------------------------------*/
goku_udc.c:420:	length = min(req->req.length - req->req.actual, max);
goku_udc.c:421:	req->req.actual += length;
goku_udc.c:424:	while (likely(count--))
goku_udc.c:432:	struct goku_udc	*dev = ep->dev;
goku_udc.c:438:	tmp = readl(&dev->regs->DataSet);
goku_udc.c:439:	buf = req->req.buf + req->req.actual;
goku_udc.c:442:	dev = ep->dev;
goku_udc.c:443:	if (unlikely(ep->num == 0 && dev->ep0state != EP0_IN))
goku_udc.c:444:		return -EL2HLT;
goku_udc.c:446:	/* NOTE:  just single-buffered PIO-IN for now.  */
goku_udc.c:447:	if (unlikely((tmp & DATASET_A(ep->num)) != 0))
goku_udc.c:451:	if (ep->num != 0)
goku_udc.c:452:		writel(~INT_EPxDATASET(ep->num), &dev->regs->int_status);
goku_udc.c:454:	count = write_packet(ep->reg_fifo, buf, req, ep->ep.maxpacket);
goku_udc.c:457:	if (unlikely(count != ep->ep.maxpacket)) {
goku_udc.c:458:		writel(~(1<<ep->num), &dev->regs->EOP);
goku_udc.c:459:		if (ep->num == 0) {
goku_udc.c:460:			dev->ep[0].stopped = 1;
goku_udc.c:461:			dev->ep0state = EP0_STATUS;
goku_udc.c:465:		if (likely(req->req.length != req->req.actual)
goku_udc.c:466:				|| req->req.zero)
goku_udc.c:474:		ep->ep.name, count, is_last ? "/last" : "",
goku_udc.c:475:		req->req.length - req->req.actual, req);
goku_udc.c:496:	regs = ep->dev->regs;
goku_udc.c:498:	buf = req->req.buf + req->req.actual;
goku_udc.c:501:	if (unlikely(ep->num == 0 && ep->dev->ep0state != EP0_OUT))
goku_udc.c:502:		return -EL2HLT;
goku_udc.c:504:	dbuff = (ep->num == 1 || ep->num == 2);
goku_udc.c:507:		if (ep->num != 0)
goku_udc.c:508:			writel(~INT_EPxDATASET(ep->num), &regs->int_status);
goku_udc.c:510:		set = readl(&regs->DataSet) & DATASET_AB(ep->num);
goku_udc.c:511:		size = readl(&regs->EPxSizeLA[ep->num]);
goku_udc.c:512:		bufferspace = req->req.length - req->req.actual;
goku_udc.c:515:		if (likely(ep->num != 0 || bufferspace != 0)) {
goku_udc.c:518:			/* use ep1/ep2 double-buffering for OUT */
goku_udc.c:520:				size = readl(&regs->EPxSizeLB[ep->num]);
goku_udc.c:525:		/* ep0out no-out-data case for set_config, etc */
goku_udc.c:530:		req->req.actual += size;
goku_udc.c:531:		is_short = (size < ep->ep.maxpacket);
goku_udc.c:533:		VDBG(ep->dev, "read %s %u bytes%s OUT req %p %u/%u\n",
goku_udc.c:534:			ep->ep.name, size, is_short ? "/S" : "",
goku_udc.c:535:			req, req->req.actual, req->req.length);
goku_udc.c:537:		while (likely(size-- != 0)) {
goku_udc.c:538:			u8	byte = (u8) readl(ep->reg_fifo);
goku_udc.c:545:				if (req->req.status != -EOVERFLOW)
goku_udc.c:546:					DBG(ep->dev, "%s overflow %u\n",
goku_udc.c:547:						ep->ep.name, size);
goku_udc.c:548:				req->req.status = -EOVERFLOW;
goku_udc.c:551:				bufferspace--;
goku_udc.c:556:		if (unlikely(is_short || req->req.actual == req->req.length)) {
goku_udc.c:557:			if (unlikely(ep->num == 0)) {
goku_udc.c:558:				/* non-control endpoints now usable? */
goku_udc.c:559:				if (ep->dev->req_config)
goku_udc.c:560:					writel(ep->dev->configured
goku_udc.c:563:						&regs->UsbState);
goku_udc.c:565:				writel(~(1<<0), &regs->EOP);
goku_udc.c:566:				ep->stopped = 1;
goku_udc.c:567:				ep->dev->ep0state = EP0_STATUS;
goku_udc.c:572:			if (dbuff && !list_empty(&ep->queue)) {
goku_udc.c:573:				req = list_entry(ep->queue.next,
goku_udc.c:587:	dev->int_enable |= INT_EPxDATASET (epnum);
goku_udc.c:588:	writel(dev->int_enable, &regs->int_enable);
goku_udc.c:596:	dev->int_enable &= ~INT_EPxDATASET (epnum);
goku_udc.c:597:	writel(dev->int_enable, &regs->int_enable);
goku_udc.c:606:	if (unlikely(list_empty (&ep->queue)))
goku_udc.c:608:	req = list_entry(ep->queue.next, struct goku_request, queue);
goku_udc.c:609:	(ep->is_in ? write_fifo : read_fifo)(ep, req);
goku_udc.c:613:/*-------------------------------------------------------------------------*/
goku_udc.c:618:	struct goku_udc_regs __iomem	*regs = ep->dev->regs;
goku_udc.c:620:	u32				start = req->req.dma;
goku_udc.c:621:	u32				end = start + req->req.length - 1;
goku_udc.c:623:	master = readl(&regs->dma_master) & MST_RW_BITS;
goku_udc.c:625:	/* re-init the bits affecting IN dma; careful with zlps */
goku_udc.c:626:	if (likely(ep->is_in)) {
goku_udc.c:628:			DBG (ep->dev, "start, IN active dma %03x!!\n",
goku_udc.c:630://			return -EL2HLT;
goku_udc.c:632:		writel(end, &regs->in_dma_end);
goku_udc.c:633:		writel(start, &regs->in_dma_start);
goku_udc.c:636:		if (unlikely(req->req.length == 0))
goku_udc.c:638:		else if ((req->req.length % ep->ep.maxpacket) != 0
goku_udc.c:639:					|| req->req.zero)
goku_udc.c:644:		ep->dev->int_enable |= INT_MSTRDEND;
goku_udc.c:646:	/* Goku DMA-OUT merges short packets, which plays poorly with
goku_udc.c:653:			DBG (ep->dev, "start, OUT active dma %03x!!\n",
goku_udc.c:655://			return -EL2HLT;
goku_udc.c:657:		writel(end, &regs->out_dma_end);
goku_udc.c:658:		writel(start, &regs->out_dma_start);
goku_udc.c:663:		ep->dev->int_enable |= INT_MSTWREND|INT_MSTWRTMOUT;
goku_udc.c:666:	writel(master, &regs->dma_master);
goku_udc.c:667:	writel(ep->dev->int_enable, &regs->int_enable);
goku_udc.c:674:	struct goku_udc_regs __iomem	*regs = ep->dev->regs;
goku_udc.c:677:	master = readl(&regs->dma_master);
goku_udc.c:679:	if (unlikely(list_empty(&ep->queue))) {
goku_udc.c:681:		if (ep->is_in)
goku_udc.c:682:			dev->int_enable &= ~INT_MSTRDEND;
goku_udc.c:684:			dev->int_enable &= ~(INT_MSTWREND|INT_MSTWRTMOUT);
goku_udc.c:685:		writel(dev->int_enable, &regs->int_enable);
goku_udc.c:688:	req = list_entry(ep->queue.next, struct goku_request, queue);
goku_udc.c:691:	if (likely(ep->is_in)) {
goku_udc.c:694:		req->req.actual = readl(&regs->in_dma_current);
goku_udc.c:702:		req->req.actual = readl(&regs->out_dma_current);
goku_udc.c:704:	req->req.actual -= req->req.dma;
goku_udc.c:705:	req->req.actual++;
goku_udc.c:709:		ep->ep.name, ep->is_in ? "IN" : "OUT",
goku_udc.c:710:		req->req.actual, req->req.length, req);
goku_udc.c:713:	if (list_empty(&ep->queue))
goku_udc.c:715:	req = list_entry(ep->queue.next, struct goku_request, queue);
goku_udc.c:721:	struct goku_udc_regs __iomem	*regs = ep->dev->regs;
goku_udc.c:732:	command(regs, COMMAND_FIFO_DISABLE, ep->num);
goku_udc.c:733:	req = list_entry(ep->queue.next, struct goku_request, queue);
goku_udc.c:734:	master = readl(&regs->dma_master) & MST_RW_BITS;
goku_udc.c:741:	if (ep->is_in) {
goku_udc.c:742:		if (unlikely((readl(&regs->dma_master) & MST_RD_ENA) == 0))
goku_udc.c:744:		curr = readl(&regs->in_dma_current);
goku_udc.c:746:		writel(curr, &regs->in_dma_end);
goku_udc.c:747:		writel(curr, &regs->in_dma_start);
goku_udc.c:751:		writel(master, &regs->dma_master);
goku_udc.c:753:		if (readl(&regs->dma_master) & MST_RD_ENA)
goku_udc.c:754:			DBG(ep->dev, "IN dma active after reset!\n");
goku_udc.c:757:		if (unlikely((readl(&regs->dma_master) & MST_WR_ENA) == 0))
goku_udc.c:759:		curr = readl(&regs->out_dma_current);
goku_udc.c:761:		writel(curr, &regs->out_dma_end);
goku_udc.c:762:		writel(curr, &regs->out_dma_start);
goku_udc.c:766:		writel(master, &regs->dma_master);
goku_udc.c:768:		if (readl(&regs->dma_master) & MST_WR_ENA)
goku_udc.c:769:			DBG(ep->dev, "OUT dma active after reset!\n");
goku_udc.c:771:	req->req.actual = (curr - req->req.dma) + 1;
goku_udc.c:772:	req->req.status = status;
goku_udc.c:774:	VDBG(ep->dev, "%s %s %s %d/%d\n", __FUNCTION__, ep->ep.name,
goku_udc.c:775:		ep->is_in ? "IN" : "OUT",
goku_udc.c:776:		req->req.actual, req->req.length);
goku_udc.c:778:	command(regs, COMMAND_FIFO_ENABLE, ep->num);
goku_udc.c:784:	command(regs, COMMAND_FIFO_ENABLE, ep->num);
goku_udc.c:785:	req->req.actual = req->req.length;
goku_udc.c:786:	req->req.status = 0;
goku_udc.c:789:/*-------------------------------------------------------------------------*/
goku_udc.c:800:	/* always require a cpu-view buffer so pio works */
goku_udc.c:802:	if (unlikely(!_req || !_req->complete
goku_udc.c:803:			|| !_req->buf || !list_empty(&req->queue)))
goku_udc.c:804:		return -EINVAL;
goku_udc.c:806:	if (unlikely(!_ep || (!ep->desc && ep->num != 0)))
goku_udc.c:807:		return -EINVAL;
goku_udc.c:808:	dev = ep->dev;
goku_udc.c:809:	if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN))
goku_udc.c:810:		return -ESHUTDOWN;
goku_udc.c:813:	if (dev->ep0state == EP0_SUSPEND)
goku_udc.c:814:		return -EBUSY;
goku_udc.c:817:	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
goku_udc.c:818:		_req->dma = pci_map_single(dev->pdev, _req->buf, _req->length,
goku_udc.c:819:			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
goku_udc.c:820:		req->mapped = 1;
goku_udc.c:825:			_ep->name, _req, _req->length, _req->buf);
goku_udc.c:828:	spin_lock_irqsave(&dev->lock, flags);
goku_udc.c:830:	_req->status = -EINPROGRESS;
goku_udc.c:831:	_req->actual = 0;
goku_udc.c:836:	if (unlikely(ep->num == 0 && ep->is_in))
goku_udc.c:837:		_req->zero = 1;
goku_udc.c:841:	if (list_empty(&ep->queue) && likely(!ep->stopped)) {
goku_udc.c:845:		if (ep->dma)
goku_udc.c:848:			status = (ep->is_in ? write_fifo : read_fifo)(ep, req);
goku_udc.c:859:		list_add_tail(&req->queue, &ep->queue);
goku_udc.c:861:	if (likely(!list_empty(&ep->queue))
goku_udc.c:862:			&& likely(ep->num != 0)
goku_udc.c:863:			&& !ep->dma
goku_udc.c:864:			&& !(dev->int_enable & INT_EPxDATASET (ep->num)))
goku_udc.c:865:		pio_irq_enable(dev, dev->regs, ep->num);
goku_udc.c:867:	spin_unlock_irqrestore(&dev->lock, flags);
goku_udc.c:878:	ep->stopped = 1;
goku_udc.c:879:	if (list_empty(&ep->queue))
goku_udc.c:881:	if (ep->dma)
goku_udc.c:883:	while (!list_empty(&ep->queue)) {
goku_udc.c:884:		req = list_entry(ep->queue.next, struct goku_request, queue);
goku_udc.c:898:	if (!_ep || !_req || (!ep->desc && ep->num != 0))
goku_udc.c:899:		return -EINVAL;
goku_udc.c:900:	dev = ep->dev;
goku_udc.c:901:	if (!dev->driver)
goku_udc.c:902:		return -ESHUTDOWN;
goku_udc.c:905:	if (dev->ep0state == EP0_SUSPEND)
goku_udc.c:906:		return -EBUSY;
goku_udc.c:908:	VDBG(dev, "%s %s %s %s %p\n", __FUNCTION__, _ep->name,
goku_udc.c:909:		ep->is_in ? "IN" : "OUT",
goku_udc.c:910:		ep->dma ? "dma" : "pio",
goku_udc.c:913:	spin_lock_irqsave(&dev->lock, flags);
goku_udc.c:916:	list_for_each_entry (req, &ep->queue, queue) {
goku_udc.c:917:		if (&req->req == _req)
goku_udc.c:920:	if (&req->req != _req) {
goku_udc.c:921:		spin_unlock_irqrestore (&dev->lock, flags);
goku_udc.c:922:		return -EINVAL;
goku_udc.c:925:	if (ep->dma && ep->queue.next == &req->queue && !ep->stopped) {
goku_udc.c:926:		abort_dma(ep, -ECONNRESET);
goku_udc.c:927:		done(ep, req, -ECONNRESET);
goku_udc.c:929:	} else if (!list_empty(&req->queue))
goku_udc.c:930:		done(ep, req, -ECONNRESET);
goku_udc.c:933:	spin_unlock_irqrestore(&dev->lock, flags);
goku_udc.c:935:	return req ? 0 : -EOPNOTSUPP;
goku_udc.c:938:/*-------------------------------------------------------------------------*/
goku_udc.c:942:	// assert (ep->num !=0)
goku_udc.c:943:	VDBG(ep->dev, "%s clear halt\n", ep->ep.name);
goku_udc.c:944:	command(ep->dev->regs, COMMAND_SETDATA0, ep->num);
goku_udc.c:945:	command(ep->dev->regs, COMMAND_STALL_CLEAR, ep->num);
goku_udc.c:946:	if (ep->stopped) {
goku_udc.c:947:		ep->stopped = 0;
goku_udc.c:948:		if (ep->dma) {
goku_udc.c:951:			if (list_empty(&ep->queue))
goku_udc.c:953:			req = list_entry(ep->queue.next, struct goku_request,
goku_udc.c:968:		return -ENODEV;
goku_udc.c:971:	if (ep->num == 0) {
goku_udc.c:973:			ep->dev->ep0state = EP0_STALL;
goku_udc.c:974:			ep->dev->ep[0].stopped = 1;
goku_udc.c:976:			return -EINVAL;
goku_udc.c:979:	} else if (!ep->desc) {
goku_udc.c:980:		DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
goku_udc.c:981:		return -EINVAL;
goku_udc.c:984:	spin_lock_irqsave(&ep->dev->lock, flags);
goku_udc.c:985:	if (!list_empty(&ep->queue))
goku_udc.c:986:		retval = -EAGAIN;
goku_udc.c:987:	else if (ep->is_in && value
goku_udc.c:989:			&& (readl(&ep->dev->regs->DataSet)
goku_udc.c:990:					& DATASET_AB(ep->num)))
goku_udc.c:991:		retval = -EAGAIN;
goku_udc.c:995:		ep->stopped = 1;
goku_udc.c:996:		VDBG(ep->dev, "%s set halt\n", ep->ep.name);
goku_udc.c:997:		command(ep->dev->regs, COMMAND_STALL, ep->num);
goku_udc.c:998:		readl(ep->reg_status);
goku_udc.c:1000:	spin_unlock_irqrestore(&ep->dev->lock, flags);
goku_udc.c:1011:		return -ENODEV;
goku_udc.c:1015:	if (ep->is_in)
goku_udc.c:1016:		return -EOPNOTSUPP;
goku_udc.c:1018:	/* ignores 16-byte dma buffer; SizeH == 0 */
goku_udc.c:1019:	regs = ep->dev->regs;
goku_udc.c:1020:	size = readl(&regs->EPxSizeLA[ep->num]) & DATASIZE;
goku_udc.c:1021:	size += readl(&regs->EPxSizeLB[ep->num]) & DATASIZE;
goku_udc.c:1022:	VDBG(ep->dev, "%s %s %u\n", __FUNCTION__, ep->ep.name, size);
goku_udc.c:1035:	VDBG(ep->dev, "%s %s\n", __FUNCTION__, ep->ep.name);
goku_udc.c:1038:	if (!ep->desc && ep->num != 0) {
goku_udc.c:1039:		DBG(ep->dev, "%s %s inactive?\n", __FUNCTION__, ep->ep.name);
goku_udc.c:1043:	regs = ep->dev->regs;
goku_udc.c:1044:	size = readl(&regs->EPxSizeLA[ep->num]);
goku_udc.c:1047:	/* Non-desirable behavior:  FIFO_CLEAR also clears the
goku_udc.c:1049:	 * the bytes out (PIO, if !ep->dma); for in, no choice.
goku_udc.c:1052:		command(regs, COMMAND_FIFO_CLEAR, ep->num);
goku_udc.c:1073:/*-------------------------------------------------------------------------*/
goku_udc.c:1077:	return -EOPNOTSUPP;
goku_udc.c:1086:/*-------------------------------------------------------------------------*/
goku_udc.c:1116:		(mask & INT_MSTRDEND) ? " in-dma" : "",
goku_udc.c:1119:		(mask & INT_MSTWREND) ? " out-dma" : "",
goku_udc.c:1138:	*size -= t;
goku_udc.c:1149:	struct goku_udc_regs __iomem	*regs = dev->regs;
goku_udc.c:1162:	tmp = readl(&regs->power_detect);
goku_udc.c:1165:		"%s - %s\n"
goku_udc.c:1170:		pci_name(dev->pdev), driver_desc,
goku_udc.c:1172:		dev->driver ? dev->driver->driver.name : "(none)",
goku_udc.c:1177:		switch(dev->ep0state){
goku_udc.c:1188:	size -= t;
goku_udc.c:1191:	dump_intmask("int_status", readl(&regs->int_status), &next, &size);
goku_udc.c:1192:	dump_intmask("int_enable", readl(&regs->int_enable), &next, &size);
goku_udc.c:1194:	if (!is_usb_connected || !dev->driver || (tmp & PW_PULLUP) == 0)
goku_udc.c:1200:			dev->irqs, readl(&regs->DataSet),
goku_udc.c:1201:			readl(&regs->EPxSingle), readl(&regs->EPxBCS),
goku_udc.c:1202:			readl(&regs->UsbState),
goku_udc.c:1203:			readl(&regs->address));
goku_udc.c:1204:	size -= t;
goku_udc.c:1207:	tmp = readl(&regs->dma_master);
goku_udc.c:1210:		(tmp & MST_EOPB_DIS) ? " eopb-" : "",
goku_udc.c:1212:		(tmp & MST_TIMEOUT_DIS) ? " tmo-" : "",
goku_udc.c:1224:	size -= t;
goku_udc.c:1229:		struct goku_ep		*ep = &dev->ep [i];
goku_udc.c:1233:		if (i && !ep->desc)
goku_udc.c:1236:		tmp = readl(ep->reg_status);
goku_udc.c:1240:			ep->ep.name,
goku_udc.c:1241:			ep->is_in ? "in" : "out",
goku_udc.c:1242:			ep->ep.maxpacket,
goku_udc.c:1243:			ep->dma ? "dma" : "pio",
goku_udc.c:1244:			ep->irqs,
goku_udc.c:1273:		size -= t;
goku_udc.c:1276:		if (list_empty(&ep->queue)) {
goku_udc.c:1280:			size -= t;
goku_udc.c:1284:		list_for_each_entry(req, &ep->queue, queue) {
goku_udc.c:1285:			if (ep->dma && req->queue.prev == &ep->queue) {
goku_udc.c:1287:					tmp = readl(&regs->in_dma_current);
goku_udc.c:1289:					tmp = readl(&regs->out_dma_current);
goku_udc.c:1290:				tmp -= req->req.dma;
goku_udc.c:1293:				tmp = req->req.actual;
goku_udc.c:1297:				&req->req, tmp, req->req.length,
goku_udc.c:1298:				req->req.buf);
goku_udc.c:1301:			size -= t;
goku_udc.c:1309:	return count - size;
goku_udc.c:1314:/*-------------------------------------------------------------------------*/
goku_udc.c:1318:	static char *names [] = { "ep0", "ep1-bulk", "ep2-bulk", "ep3-bulk" };
goku_udc.c:1322:	INIT_LIST_HEAD (&dev->gadget.ep_list);
goku_udc.c:1323:	dev->gadget.ep0 = &dev->ep [0].ep;
goku_udc.c:1324:	dev->gadget.speed = USB_SPEED_UNKNOWN;
goku_udc.c:1325:	dev->ep0state = EP0_DISCONNECT;
goku_udc.c:1326:	dev->irqs = 0;
goku_udc.c:1329:		struct goku_ep	*ep = &dev->ep[i];
goku_udc.c:1331:		ep->num = i;
goku_udc.c:1332:		ep->ep.name = names[i];
goku_udc.c:1333:		ep->reg_fifo = &dev->regs->ep_fifo [i];
goku_udc.c:1334:		ep->reg_status = &dev->regs->ep_status [i];
goku_udc.c:1335:		ep->reg_mode = &dev->regs->ep_mode[i];
goku_udc.c:1337:		ep->ep.ops = &goku_ep_ops;
goku_udc.c:1338:		list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
goku_udc.c:1339:		ep->dev = dev;
goku_udc.c:1340:		INIT_LIST_HEAD (&ep->queue);
goku_udc.c:1345:	dev->ep[0].reg_mode = NULL;
goku_udc.c:1346:	dev->ep[0].ep.maxpacket = MAX_EP0_SIZE;
goku_udc.c:1347:	list_del_init (&dev->ep[0].ep.ep_list);
goku_udc.c:1352:	struct goku_udc_regs __iomem	*regs = dev->regs;
goku_udc.c:1354:	writel(0, &regs->power_detect);
goku_udc.c:1355:	writel(0, &regs->int_enable);
goku_udc.c:1356:	readl(&regs->int_enable);
goku_udc.c:1357:	dev->int_enable = 0;
goku_udc.c:1359:	/* deassert reset, leave USB D+ at hi-Z (no pullup)
goku_udc.c:1363:	writel(PW_RESETB, &regs->power_detect);
goku_udc.c:1364:	readl(&regs->int_enable);
goku_udc.c:1369:	struct goku_udc_regs __iomem	*regs = dev->regs;
goku_udc.c:1376:	//writel(MST_EOPB_ENA | MST_TIMEOUT_ENA, &regs->dma_master);
goku_udc.c:1383:		, &regs->reqmode);
goku_udc.c:1386:		dev->ep[i].irqs = 0;
goku_udc.c:1390:		writel(0, &regs->descriptors[i]);
goku_udc.c:1391:	writel(0, &regs->UsbReady);
goku_udc.c:1394:	writel(PW_RESETB | PW_PULLUP, &regs->power_detect);
goku_udc.c:1395:	dev->int_enable = INT_DEVWIDE | INT_EP0;
goku_udc.c:1396:	writel(dev->int_enable, &dev->regs->int_enable);
goku_udc.c:1397:	readl(&regs->int_enable);
goku_udc.c:1398:	dev->gadget.speed = USB_SPEED_FULL;
goku_udc.c:1399:	dev->ep0state = EP0_IDLE;
goku_udc.c:1405:	if (readl(&dev->regs->power_detect) & PW_DETECT)
goku_udc.c:1409:		dev->int_enable = INT_PWRDETECT;
goku_udc.c:1410:		writel(dev->int_enable, &dev->regs->int_enable);
goku_udc.c:1414:/*-------------------------------------------------------------------------*/
goku_udc.c:1417: * - one bus driver, initted first;
goku_udc.c:1418: * - one function driver, initted second
goku_udc.c:1425: * non-control requests.  then usb traffic follows until a
goku_udc.c:1435:			|| driver->speed != USB_SPEED_FULL
goku_udc.c:1436:			|| !driver->bind
goku_udc.c:1437:			|| !driver->unbind
goku_udc.c:1438:			|| !driver->disconnect
goku_udc.c:1439:			|| !driver->setup)
goku_udc.c:1440:		return -EINVAL;
goku_udc.c:1442:		return -ENODEV;
goku_udc.c:1443:	if (dev->driver)
goku_udc.c:1444:		return -EBUSY;
goku_udc.c:1447:	driver->driver.bus = NULL;
goku_udc.c:1448:	dev->driver = driver;
goku_udc.c:1449:	dev->gadget.dev.driver = &driver->driver;
goku_udc.c:1450:	retval = driver->bind(&dev->gadget);
goku_udc.c:1452:		DBG(dev, "bind to driver %s --> error %d\n",
goku_udc.c:1453:				driver->driver.name, retval);
goku_udc.c:1454:		dev->driver = NULL;
goku_udc.c:1455:		dev->gadget.dev.driver = NULL;
goku_udc.c:1464:	DBG(dev, "registered gadget driver '%s'\n", driver->driver.name);
goku_udc.c:1476:	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
goku_udc.c:1482:		nuke(&dev->ep [i], -ESHUTDOWN);
goku_udc.c:1484:		spin_unlock(&dev->lock);
goku_udc.c:1485:		driver->disconnect(&dev->gadget);
goku_udc.c:1486:		spin_lock(&dev->lock);
goku_udc.c:1489:	if (dev->driver)
goku_udc.c:1499:		return -ENODEV;
goku_udc.c:1500:	if (!driver || driver != dev->driver)
goku_udc.c:1501:		return -EINVAL;
goku_udc.c:1503:	spin_lock_irqsave(&dev->lock, flags);
goku_udc.c:1504:	dev->driver = NULL;
goku_udc.c:1506:	spin_unlock_irqrestore(&dev->lock, flags);
goku_udc.c:1508:	driver->unbind(&dev->gadget);
goku_udc.c:1510:	DBG(dev, "unregistered driver '%s'\n", driver->driver.name);
goku_udc.c:1516:/*-------------------------------------------------------------------------*/
goku_udc.c:1520:	struct goku_udc_regs __iomem	*regs = dev->regs;
goku_udc.c:1525:	ctrl.bRequestType = readl(&regs->bRequestType);
goku_udc.c:1526:	ctrl.bRequest = readl(&regs->bRequest);
goku_udc.c:1527:	ctrl.wValue  = (readl(&regs->wValueH)  << 8) | readl(&regs->wValueL);
goku_udc.c:1528:	ctrl.wIndex  = (readl(&regs->wIndexH)  << 8) | readl(&regs->wIndexL);
goku_udc.c:1529:	ctrl.wLength = (readl(&regs->wLengthH) << 8) | readl(&regs->wLengthL);
goku_udc.c:1530:	writel(0, &regs->SetupRecv);
goku_udc.c:1532:	nuke(&dev->ep[0], 0);
goku_udc.c:1533:	dev->ep[0].stopped = 0;
goku_udc.c:1535:		dev->ep[0].is_in = 1;
goku_udc.c:1536:		dev->ep0state = EP0_IN;
goku_udc.c:1538:		writel(ICONTROL_STATUSNAK, &dev->regs->IntControl);
goku_udc.c:1540:		dev->ep[0].is_in = 0;
goku_udc.c:1541:		dev->ep0state = EP0_OUT;
goku_udc.c:1553:				if (tmp > 3 || (!dev->ep[tmp].desc && tmp != 0))
goku_udc.c:1556:					if (!dev->ep[tmp].is_in)
goku_udc.c:1559:					if (dev->ep[tmp].is_in)
goku_udc.c:1565:					goku_clear_halt(&dev->ep[tmp]);
goku_udc.c:1568:				writel(~(1<<0), &regs->EOP);
goku_udc.c:1569:				dev->ep[0].stopped = 1;
goku_udc.c:1570:				dev->ep0state = EP0_STATUS;
goku_udc.c:1596:	dev->req_config = (ctrl.bRequest == USB_REQ_SET_CONFIGURATION
goku_udc.c:1598:	if (unlikely(dev->req_config))
goku_udc.c:1599:		dev->configured = (ctrl.wValue != 0);
goku_udc.c:1604:	spin_unlock (&dev->lock);
goku_udc.c:1605:	tmp = dev->driver->setup(&dev->gadget, &ctrl);
goku_udc.c:1606:	spin_lock (&dev->lock);
goku_udc.c:1614:		dev->ep[0].stopped = 1;
goku_udc.c:1615:		dev->ep0state = EP0_STALL;
goku_udc.c:1623:		writel(~irqbit, &regs->int_status); \
goku_udc.c:1630:	struct goku_udc_regs __iomem	*regs = dev->regs;
goku_udc.c:1635:	spin_lock(&dev->lock);
goku_udc.c:1638:	stat = readl(&regs->int_status) & dev->int_enable;
goku_udc.c:1641:	dev->irqs++;
goku_udc.c:1643:	/* device-wide irqs */
goku_udc.c:1647:			stop_activity(dev, dev->driver);
goku_udc.c:1650:			// FIXME have a neater way to prevent re-enumeration
goku_udc.c:1651:			dev->driver = NULL;
goku_udc.c:1655:			writel(~stat, &regs->int_status);
goku_udc.c:1656:			if (readl(&dev->regs->power_detect) & PW_DETECT) {
goku_udc.c:1661:				if (dev->gadget.speed == USB_SPEED_FULL)
goku_udc.c:1662:					stop_activity(dev, dev->driver);
goku_udc.c:1663:				dev->ep0state = EP0_DISCONNECT;
goku_udc.c:1664:				dev->int_enable = INT_DEVWIDE;
goku_udc.c:1665:				writel(dev->int_enable, &dev->regs->int_enable);
goku_udc.c:1673:			if (readl(&regs->ep_status[0]) & EPxSTATUS_SUSPEND) {
goku_udc.c:1674:				switch (dev->ep0state) {
goku_udc.c:1682:				dev->ep0state = EP0_SUSPEND;
goku_udc.c:1683:				if (dev->gadget.speed != USB_SPEED_UNKNOWN
goku_udc.c:1684:						&& dev->driver
goku_udc.c:1685:						&& dev->driver->suspend) {
goku_udc.c:1686:					spin_unlock(&dev->lock);
goku_udc.c:1687:					dev->driver->suspend(&dev->gadget);
goku_udc.c:1688:					spin_lock(&dev->lock);
goku_udc.c:1691:				if (dev->ep0state != EP0_SUSPEND) {
goku_udc.c:1693:						dev->ep0state);
goku_udc.c:1697:				dev->ep0state = EP0_IDLE;
goku_udc.c:1698:				if (dev->gadget.speed != USB_SPEED_UNKNOWN
goku_udc.c:1699:						&& dev->driver
goku_udc.c:1700:						&& dev->driver->resume) {
goku_udc.c:1701:					spin_unlock(&dev->lock);
goku_udc.c:1702:					dev->driver->resume(&dev->gadget);
goku_udc.c:1703:					spin_lock(&dev->lock);
goku_udc.c:1711:				dev->driver->driver.name);
goku_udc.c:1717:	 * no transition {EP0_STATUS, EP0_STALL} --> EP0_IDLE; saves irqs
goku_udc.c:1721:		dev->ep[0].irqs++;
goku_udc.c:1726:		if (dev->ep0state == EP0_IN) {
goku_udc.c:1727:			ep = &dev->ep[0];
goku_udc.c:1728:			ep->irqs++;
goku_udc.c:1730:			writel(~(1<<0), &regs->EOP);
goku_udc.c:1731:			dev->ep0state = EP0_STATUS;
goku_udc.c:1736:		ep = &dev->ep[0];
goku_udc.c:1737:		ep->irqs++;
goku_udc.c:1744:		ep = &dev->ep[UDC_MSTRD_ENDPOINT];
goku_udc.c:1745:		ep->irqs++;
goku_udc.c:1750:		ep = &dev->ep[UDC_MSTWR_ENDPOINT];
goku_udc.c:1751:		ep->irqs++;
goku_udc.c:1756:		ep = &dev->ep[UDC_MSTWR_ENDPOINT];
goku_udc.c:1757:		ep->irqs++;
goku_udc.c:1758:		ERROR(dev, "%s write timeout ?\n", ep->ep.name);
goku_udc.c:1768:		ep = &dev->ep[i];
goku_udc.c:1770:		if (list_empty (&ep->queue))
goku_udc.c:1774:		ep->irqs++;
goku_udc.c:1777:	if (rescans--)
goku_udc.c:1781:	(void)readl(&regs->int_enable);
goku_udc.c:1782:	spin_unlock(&dev->lock);
goku_udc.c:1785:				readl(&regs->int_status), dev->int_enable);
goku_udc.c:1791:/*-------------------------------------------------------------------------*/
goku_udc.c:1808:	if (dev->driver) {
goku_udc.c:1811:				dev->driver->driver.name);
goku_udc.c:1812:		usb_gadget_unregister_driver(dev->driver);
goku_udc.c:1818:	if (dev->regs)
goku_udc.c:1820:	if (dev->got_irq)
goku_udc.c:1821:		free_irq(pdev->irq, dev);
goku_udc.c:1822:	if (dev->regs)
goku_udc.c:1823:		iounmap(dev->regs);
goku_udc.c:1824:	if (dev->got_region)
goku_udc.c:1827:	if (dev->enabled)
goku_udc.c:1829:	device_unregister(&dev->gadget.dev);
goku_udc.c:1832:	dev->regs = NULL;
goku_udc.c:1855:		return -EBUSY;
goku_udc.c:1857:	if (!pdev->irq) {
goku_udc.c:1859:		retval = -ENODEV;
goku_udc.c:1867:		retval = -ENOMEM;
goku_udc.c:1872:	spin_lock_init(&dev->lock);
goku_udc.c:1873:	dev->pdev = pdev;
goku_udc.c:1874:	dev->gadget.ops = &goku_ops;
goku_udc.c:1877:	strcpy(dev->gadget.dev.bus_id, "gadget");
goku_udc.c:1878:	dev->gadget.dev.parent = &pdev->dev;
goku_udc.c:1879:	dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
goku_udc.c:1880:	dev->gadget.dev.release = gadget_release;
goku_udc.c:1881:	dev->gadget.name = driver_name;
goku_udc.c:1889:	dev->enabled = 1;
goku_udc.c:1895:		retval = -EBUSY;
goku_udc.c:1898:	dev->got_region = 1;
goku_udc.c:1903:		retval = -EFAULT;
goku_udc.c:1906:	dev->regs = (struct goku_udc_regs __iomem *) base;
goku_udc.c:1912:	scnprintf(buf, sizeof buf, "%d", pdev->irq);
goku_udc.c:1915:	bufp = __irq_itoa(pdev->irq);
goku_udc.c:1922:	if (request_irq(pdev->irq, goku_irq, SA_SHIRQ/*|SA_SAMPLE_RANDOM*/,
goku_udc.c:1925:		retval = -EBUSY;
goku_udc.c:1928:	dev->got_irq = 1;
goku_udc.c:1939:	device_register(&dev->gadget.dev);
goku_udc.c:1950:/*-------------------------------------------------------------------------*/
inode.c:2: * inode.c -- user mode filesystem api for usb gadget controllers
inode.c:4: * Copyright (C) 2003-2004 David Brownell
inode.c:19: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
inode.c:50: * Key parts that must be USB-specific are protocols defining how the
inode.c:56: * - First, dev_config() is called when /dev/gadget/$CHIP is configured
inode.c:61: * - Then either immediately, or after a SET_CONFIGURATION control request,
inode.c:84:/*----------------------------------------------------------------------*/
inode.c:103:	 * - (UN)CONNECTED: read usb_gadgetfs_event(s) from it
inode.c:104:	 * - SETUP: read/write will transfer control data and succeed;
inode.c:139:	/* the rest is basically write-once */
inode.c:156:	atomic_inc (&data->count);
inode.c:161:	if (likely (!atomic_dec_and_test (&data->count)))
inode.c:164:	BUG_ON (waitqueue_active (&data->wait));
inode.c:176:	dev->state = STATE_DEV_DISABLED;
inode.c:177:	atomic_set (&dev->count, 1);
inode.c:178:	spin_lock_init (&dev->lock);
inode.c:179:	INIT_LIST_HEAD (&dev->epfiles);
inode.c:180:	init_waitqueue_head (&dev->wait);
inode.c:184:/*----------------------------------------------------------------------*/
inode.c:200:	/* must hold dev->lock before accessing ep or req */
inode.c:214:	atomic_inc (&data->count);
inode.c:219:	if (likely (!atomic_dec_and_test (&data->count)))
inode.c:221:	put_dev (data->dev);
inode.c:223:	BUG_ON (!list_empty (&data->epfiles));
inode.c:224:	BUG_ON (waitqueue_active (&data->wait));
inode.c:225:	BUG_ON (down_trylock (&data->lock) != 0);
inode.c:229:/*----------------------------------------------------------------------*/
inode.c:239:/*----------------------------------------------------------------------*/
inode.c:245:/* too wordy: dev_printk(level , &(d)->gadget->dev , fmt , ## args) */
inode.c:272:/*----------------------------------------------------------------------*/
inode.c:276: * After opening, configure non-control endpoints.  Then use normal
inode.c:283:	struct ep_data	*epdata = ep->driver_data;
inode.c:285:	if (!req->context)
inode.c:287:	if (req->status)
inode.c:288:		epdata->status = req->status;
inode.c:290:		epdata->status = req->actual;
inode.c:291:	complete ((struct completion *)req->context);
inode.c:295: * still need dev->lock to use epdata->ep.
inode.c:303:		if (down_trylock (&epdata->lock) != 0)
inode.c:305:		if (epdata->state != STATE_EP_ENABLED) {
inode.c:306:			up (&epdata->lock);
inode.c:308:			val = -EAGAIN;
inode.c:314:	if ((val = down_interruptible (&epdata->lock)) < 0)
inode.c:317:	switch (epdata->state) {
inode.c:321:		DBG (epdata->dev, "%s wait for host\n", epdata->name);
inode.c:322:		if ((val = wait_event_interruptible (epdata->wait, 
inode.c:323:				epdata->state != STATE_EP_DEFER_ENABLE
inode.c:324:				|| epdata->dev->state == STATE_DEV_UNBOUND
inode.c:332:				shortname, epdata, epdata->state);
inode.c:335:		val = -ENODEV;
inode.c:337:		up (&epdata->lock);
inode.c:348:	spin_lock_irq (&epdata->dev->lock);
inode.c:349:	if (likely (epdata->ep != NULL)) {
inode.c:350:		struct usb_request	*req = epdata->req;
inode.c:352:		req->context = &done;
inode.c:353:		req->complete = epio_complete;
inode.c:354:		req->buf = buf;
inode.c:355:		req->length = len;
inode.c:356:		value = usb_ep_queue (epdata->ep, req, GFP_ATOMIC);
inode.c:358:		value = -ENODEV;
inode.c:359:	spin_unlock_irq (&epdata->dev->lock);
inode.c:364:			spin_lock_irq (&epdata->dev->lock);
inode.c:365:			if (likely (epdata->ep != NULL)) {
inode.c:366:				DBG (epdata->dev, "%s i/o interrupted\n",
inode.c:367:						epdata->name);
inode.c:368:				usb_ep_dequeue (epdata->ep, epdata->req);
inode.c:369:				spin_unlock_irq (&epdata->dev->lock);
inode.c:372:				if (epdata->status == -ECONNRESET)
inode.c:373:					epdata->status = -EINTR;
inode.c:375:				spin_unlock_irq (&epdata->dev->lock);
inode.c:377:				DBG (epdata->dev, "endpoint gone\n");
inode.c:378:				epdata->status = -ENODEV;
inode.c:381:		return epdata->status;
inode.c:391:	struct ep_data		*data = fd->private_data;
inode.c:395:	if ((value = get_ready_ep (fd->f_flags, data)) < 0)
inode.c:399:	if (data->desc.bEndpointAddress & USB_DIR_IN) {
inode.c:400:		if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
inode.c:402:			return -EINVAL;
inode.c:403:		DBG (data->dev, "%s halt\n", data->name);
inode.c:404:		spin_lock_irq (&data->dev->lock);
inode.c:405:		if (likely (data->ep != NULL))
inode.c:406:			usb_ep_set_halt (data->ep);
inode.c:407:		spin_unlock_irq (&data->dev->lock);
inode.c:408:		up (&data->lock);
inode.c:409:		return -EBADMSG;
inode.c:414:	value = -ENOMEM;
inode.c:420:	VDEBUG (data->dev, "%s read %d OUT, status %d\n",
inode.c:421:		data->name, len, value);
inode.c:423:		value = -EFAULT;
inode.c:426:	up (&data->lock);
inode.c:435:	struct ep_data		*data = fd->private_data;
inode.c:439:	if ((value = get_ready_ep (fd->f_flags, data)) < 0)
inode.c:443:	if (!(data->desc.bEndpointAddress & USB_DIR_IN)) {
inode.c:444:		if ((data->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
inode.c:446:			return -EINVAL;
inode.c:447:		DBG (data->dev, "%s halt\n", data->name);
inode.c:448:		spin_lock_irq (&data->dev->lock);
inode.c:449:		if (likely (data->ep != NULL))
inode.c:450:			usb_ep_set_halt (data->ep);
inode.c:451:		spin_unlock_irq (&data->dev->lock);
inode.c:452:		up (&data->lock);
inode.c:453:		return -EBADMSG;
inode.c:458:	value = -ENOMEM;
inode.c:463:		value = -EFAULT;
inode.c:468:	VDEBUG (data->dev, "%s write %d IN, status %d\n",
inode.c:469:		data->name, len, value);
inode.c:471:	up (&data->lock);
inode.c:479:	struct ep_data		*data = fd->private_data;
inode.c:482:	if (data->state != STATE_EP_UNBOUND) {
inode.c:483:		data->state = STATE_EP_DISABLED;
inode.c:484:		data->desc.bDescriptorType = 0;
inode.c:485:		data->hs_desc.bDescriptorType = 0;
inode.c:494:	struct ep_data		*data = fd->private_data;
inode.c:497:	if ((status = get_ready_ep (fd->f_flags, data)) < 0)
inode.c:500:	spin_lock_irq (&data->dev->lock);
inode.c:501:	if (likely (data->ep != NULL)) {
inode.c:504:			status = usb_ep_fifo_status (data->ep);
inode.c:507:			usb_ep_fifo_flush (data->ep);
inode.c:510:			status = usb_ep_clear_halt (data->ep);
inode.c:513:			status = -ENOTTY;
inode.c:516:		status = -ENODEV;
inode.c:517:	spin_unlock_irq (&data->dev->lock);
inode.c:518:	up (&data->lock);
inode.c:522:/*----------------------------------------------------------------------*/
inode.c:536:	struct kiocb_priv	*priv = iocb->private;
inode.c:541:	epdata = priv->epdata;
inode.c:542:	// spin_lock(&epdata->dev->lock);
inode.c:544:	if (likely(epdata && epdata->ep && priv->req))
inode.c:545:		value = usb_ep_dequeue (epdata->ep, priv->req);
inode.c:547:		value = -EINVAL;
inode.c:548:	// spin_unlock(&epdata->dev->lock);
inode.c:557:	struct kiocb_priv	*priv = iocb->private;
inode.c:558:	ssize_t			status = priv->actual;
inode.c:561:	status = copy_to_user(priv->ubuf, priv->buf, priv->actual);
inode.c:563:		status = -EFAULT;
inode.c:565:		status = priv->actual;
inode.c:566:	kfree(priv->buf);
inode.c:574:	struct kiocb		*iocb = req->context;
inode.c:575:	struct kiocb_priv	*priv = iocb->private;
inode.c:576:	struct ep_data		*epdata = priv->epdata;
inode.c:579:	spin_lock(&epdata->dev->lock);
inode.c:580:	priv->req = NULL;
inode.c:581:	priv->epdata = NULL;
inode.c:582:	if (NULL == iocb->ki_retry
inode.c:583:			|| unlikely(0 == req->actual)
inode.c:585:		kfree(req->buf);
inode.c:587:		iocb->private = NULL;
inode.c:588:		/* aio_complete() reports bytes-transferred _and_ faults */
inode.c:593:				req->actual ? req->actual : req->status,
inode.c:594:				req->status);
inode.c:597:		if (unlikely(0 != req->status))
inode.c:598:			DBG(epdata->dev, "%s fault %d len %d\n",
inode.c:599:				ep->name, req->status, req->actual);
inode.c:601:		priv->buf = req->buf;
inode.c:602:		priv->actual = req->actual;
inode.c:605:	spin_unlock(&epdata->dev->lock);
inode.c:620:	struct kiocb_priv	*priv = (void *) &iocb->private;
inode.c:626:		value = -ENOMEM;
inode.c:631:	iocb->private = priv;
inode.c:632:	priv->ubuf = ubuf;
inode.c:634:	value = get_ready_ep(iocb->ki_filp->f_flags, epdata);
inode.c:640:	iocb->ki_cancel = ep_aio_cancel;
inode.c:642:	priv->epdata = epdata;
inode.c:643:	priv->actual = 0;
inode.c:648:	spin_lock_irq(&epdata->dev->lock);
inode.c:649:	if (likely(epdata->ep)) {
inode.c:650:		req = usb_ep_alloc_request(epdata->ep, GFP_ATOMIC);
inode.c:652:			priv->req = req;
inode.c:653:			req->buf = buf;
inode.c:654:			req->length = len;
inode.c:655:			req->complete = ep_aio_complete;
inode.c:656:			req->context = iocb;
inode.c:657:			value = usb_ep_queue(epdata->ep, req, GFP_ATOMIC);
inode.c:659:				usb_ep_free_request(epdata->ep, req);
inode.c:661:			value = -EAGAIN;
inode.c:663:		value = -ENODEV;
inode.c:664:	spin_unlock_irq(&epdata->dev->lock);
inode.c:666:	up(&epdata->lock);
inode.c:672:		value = -EIOCBQUEUED;
inode.c:679:	struct ep_data		*epdata = iocb->ki_filp->private_data;
inode.c:682:	if (unlikely(epdata->desc.bEndpointAddress & USB_DIR_IN))
inode.c:683:		return -EINVAL;
inode.c:686:		return -ENOMEM;
inode.c:687:	iocb->ki_retry = ep_aio_read_retry;
inode.c:694:	struct ep_data		*epdata = iocb->ki_filp->private_data;
inode.c:697:	if (unlikely(!(epdata->desc.bEndpointAddress & USB_DIR_IN)))
inode.c:698:		return -EINVAL;
inode.c:701:		return -ENOMEM;
inode.c:704:		return -EFAULT;
inode.c:709:/*----------------------------------------------------------------------*/
inode.c:741:	struct ep_data		*data = fd->private_data;
inode.c:746:	if ((value = down_interruptible (&data->lock)) < 0)
inode.c:749:	if (data->state != STATE_EP_READY) {
inode.c:750:		value = -EL2HLT;
inode.c:763:		DBG(data->dev, "config %s, bad tag %d\n", data->name, tag);
inode.c:767:	len -= 4;
inode.c:774:	if (copy_from_user (&data->desc, buf, USB_DT_ENDPOINT_SIZE)) {
inode.c:777:	if (data->desc.bLength != USB_DT_ENDPOINT_SIZE
inode.c:778:			|| data->desc.bDescriptorType != USB_DT_ENDPOINT)
inode.c:783:		if (copy_from_user (&data->hs_desc, buf + USB_DT_ENDPOINT_SIZE,
inode.c:787:		if (data->hs_desc.bLength != USB_DT_ENDPOINT_SIZE
inode.c:788:				|| data->hs_desc.bDescriptorType
inode.c:790:			DBG(data->dev, "config %s, bad hs length or type\n",
inode.c:791:					data->name);
inode.c:797:	spin_lock_irq (&data->dev->lock);
inode.c:798:	if (data->dev->state == STATE_DEV_UNBOUND) {
inode.c:799:		value = -ENOENT;
inode.c:801:	} else if ((ep = data->ep) == NULL) {
inode.c:802:		value = -ENODEV;
inode.c:805:	switch (data->dev->gadget->speed) {
inode.c:808:		value = usb_ep_enable (ep, &data->desc);
inode.c:810:			data->state = STATE_EP_ENABLED;
inode.c:815:		value = usb_ep_enable (ep, &data->hs_desc);
inode.c:817:			data->state = STATE_EP_ENABLED;
inode.c:821:		DBG (data->dev, "unconnected, %s init deferred\n",
inode.c:822:				data->name);
inode.c:823:		data->state = STATE_EP_DEFER_ENABLE;
inode.c:826:		fd->f_op = &ep_io_operations;
inode.c:828:	spin_unlock_irq (&data->dev->lock);
inode.c:831:		data->desc.bDescriptorType = 0;
inode.c:832:		data->hs_desc.bDescriptorType = 0;
inode.c:834:	up (&data->lock);
inode.c:837:	value = -EINVAL;
inode.c:840:	value = -EFAULT;
inode.c:847:	struct ep_data		*data = inode->u.generic_ip;
inode.c:848:	int			value = -EBUSY;
inode.c:850:	if (down_interruptible (&data->lock) != 0)
inode.c:851:		return -EINTR;
inode.c:852:	spin_lock_irq (&data->dev->lock);
inode.c:853:	if (data->dev->state == STATE_DEV_UNBOUND)
inode.c:854:		value = -ENOENT;
inode.c:855:	else if (data->state == STATE_EP_DISABLED) {
inode.c:857:		data->state = STATE_EP_READY;
inode.c:859:		fd->private_data = data;
inode.c:860:		VDEBUG (data->dev, "%s ready\n", data->name);
inode.c:862:		DBG (data->dev, "%s state %d\n",
inode.c:863:			data->name, data->state);
inode.c:864:	spin_unlock_irq (&data->dev->lock);
inode.c:865:	up (&data->lock);
inode.c:879:/*----------------------------------------------------------------------*/
inode.c:885: * use this facility may be too simple-minded for real applications.
inode.c:890:	wake_up (&dev->wait);
inode.c:891:	kill_fasync (&dev->fasync, SIGIO, POLL_IN);
inode.c:896:	struct dev_data		*dev = ep->driver_data;
inode.c:898:	if (req->buf != dev->rbuf) {
inode.c:899:		usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
inode.c:900:		req->buf = dev->rbuf;
inode.c:901:		req->dma = DMA_ADDR_INVALID;
inode.c:903:	req->complete = epio_complete;
inode.c:904:	dev->setup_out_ready = 0;
inode.c:909:	struct dev_data		*dev = ep->driver_data;
inode.c:913:	if (!dev->setup_in) {
inode.c:914:		dev->setup_out_error = (req->status != 0);
inode.c:915:		if (!dev->setup_out_error)
inode.c:917:		dev->setup_out_ready = 1;
inode.c:919:	} else if (dev->state == STATE_SETUP)
inode.c:920:		dev->state = STATE_CONNECTED;
inode.c:923:	if (free && req->buf != &dev->rbuf)
inode.c:925:	req->complete = epio_complete;
inode.c:930:	struct dev_data	*dev = ep->driver_data;
inode.c:932:	if (dev->setup_out_ready) {
inode.c:934:		return -EBUSY;
inode.c:936:	if (len > sizeof (dev->rbuf))
inode.c:937:		req->buf = usb_ep_alloc_buffer (ep, len, &req->dma, GFP_ATOMIC);
inode.c:938:	if (req->buf == 0) {
inode.c:939:		req->buf = dev->rbuf;
inode.c:940:		return -ENOMEM;
inode.c:942:	req->complete = ep0_complete;
inode.c:943:	req->length = len;
inode.c:950:	struct dev_data			*dev = fd->private_data;
inode.c:954:	spin_lock_irq (&dev->lock);
inode.c:957:	if (dev->setup_abort) {
inode.c:958:		dev->setup_abort = 0;
inode.c:959:		retval = -EIDRM;
inode.c:964:	if ((state = dev->state) == STATE_SETUP) {
inode.c:966:		if (dev->setup_in) {		/* stall IN */
inode.c:968:			(void) usb_ep_set_halt (dev->gadget->ep0);
inode.c:969:			retval = -EL2HLT;
inode.c:970:			dev->state = STATE_CONNECTED;
inode.c:973:			struct usb_ep		*ep = dev->gadget->ep0;
inode.c:974:			struct usb_request	*req = dev->req;
inode.c:978:			dev->state = STATE_CONNECTED;
inode.c:981:			if (dev->current_config) {
inode.c:984:				if (dev->gadget->speed == USB_SPEED_HIGH)
inode.c:985:					power = dev->hs_config->bMaxPower;
inode.c:988:					power = dev->config->bMaxPower;
inode.c:989:				usb_gadget_vbus_draw(dev->gadget, 2 * power);
inode.c:993:			if ((fd->f_flags & O_NONBLOCK) != 0
inode.c:994:					&& !dev->setup_out_ready) {
inode.c:995:				retval = -EAGAIN;
inode.c:998:			spin_unlock_irq (&dev->lock);
inode.c:999:			retval = wait_event_interruptible (dev->wait,
inode.c:1000:					dev->setup_out_ready != 0);
inode.c:1003:			spin_lock_irq (&dev->lock);
inode.c:1006:			if (dev->setup_out_error)
inode.c:1007:				retval = -EIO;
inode.c:1009:				len = min (len, (size_t)dev->req->actual);
inode.c:1011:				if (copy_to_user (buf, &dev->req->buf, len))
inode.c:1012:					retval = -EFAULT;
inode.c:1013:				clean_req (dev->gadget->ep0, dev->req);
inode.c:1021:	if (len < sizeof dev->event [0]) {
inode.c:1022:		retval = -EINVAL;
inode.c:1025:	len -= len % sizeof (struct usb_gadgetfs_event);
inode.c:1026:	dev->usermode_setup = 1;
inode.c:1030:	if (dev->ev_next != 0) {
inode.c:1032:		int			tmp = dev->ev_next;
inode.c:1039:			if (dev->event [i].type == GADGETFS_SETUP) {
inode.c:1046:		spin_unlock_irq (&dev->lock);
inode.c:1047:		if (copy_to_user (buf, &dev->event, len))
inode.c:1048:			retval = -EFAULT;
inode.c:1057:			spin_lock_irq (&dev->lock);
inode.c:1058:			dev->ev_next -= len;
inode.c:1059:			if (dev->ev_next != 0)
inode.c:1060:				memmove (&dev->event, &dev->event [len],
inode.c:1062:						* (tmp - len));
inode.c:1064:				dev->state = STATE_SETUP;
inode.c:1065:			spin_unlock_irq (&dev->lock);
inode.c:1069:	if (fd->f_flags & O_NONBLOCK) {
inode.c:1070:		retval = -EAGAIN;
inode.c:1077:		retval = -ESRCH;
inode.c:1081:		spin_unlock_irq (&dev->lock);
inode.c:1085:		retval = wait_event_interruptible (dev->wait,
inode.c:1086:				dev->ev_next != 0);
inode.c:1089:		spin_lock_irq (&dev->lock);
inode.c:1094:	spin_unlock_irq (&dev->lock);
inode.c:1107:		if (dev->state == STATE_SETUP)
inode.c:1108:			dev->setup_abort = 1;
inode.c:1111:		dev->ev_next = 0;
inode.c:1116:		for (i = 0; i != dev->ev_next; i++) {
inode.c:1117:			if (dev->event [i].type != type)
inode.c:1120:			dev->ev_next--;
inode.c:1121:			if (i == dev->ev_next)
inode.c:1124:			memmove (&dev->event [i], &dev->event [i + 1],
inode.c:1126:					* (dev->ev_next - i));
inode.c:1132:	event = &dev->event [dev->ev_next++];
inode.c:1133:	BUG_ON (dev->ev_next > N_EVENT);
inode.c:1134:	VDEBUG (dev, "ev %d, next %d\n", type, dev->ev_next);
inode.c:1136:	event->type = type;
inode.c:1143:	struct dev_data		*dev = fd->private_data;
inode.c:1144:	ssize_t			retval = -ESRCH;
inode.c:1146:	spin_lock_irq (&dev->lock);
inode.c:1149:	if (dev->setup_abort) {
inode.c:1150:		dev->setup_abort = 0;
inode.c:1151:		retval = -EIDRM;
inode.c:1154:	} else if (dev->state == STATE_SETUP) {
inode.c:1157:		if (dev->setup_in) {
inode.c:1158:			retval = setup_req (dev->gadget->ep0, dev->req, len);
inode.c:1160:				spin_unlock_irq (&dev->lock);
inode.c:1161:				if (copy_from_user (dev->req->buf, buf, len))
inode.c:1162:					retval = -EFAULT;
inode.c:1165:						dev->gadget->ep0, dev->req,
inode.c:1168:					spin_lock_irq (&dev->lock);
inode.c:1169:					clean_req (dev->gadget->ep0, dev->req);
inode.c:1170:					spin_unlock_irq (&dev->lock);
inode.c:1178:		} else if (dev->setup_can_stall) {
inode.c:1180:			(void) usb_ep_set_halt (dev->gadget->ep0);
inode.c:1181:			retval = -EL2HLT;
inode.c:1182:			dev->state = STATE_CONNECTED;
inode.c:1187:		DBG (dev, "fail %s, state %d\n", __FUNCTION__, dev->state);
inode.c:1189:	spin_unlock_irq (&dev->lock);
inode.c:1196:	struct dev_data		*dev = fd->private_data;
inode.c:1199:	return fasync_helper (f, fd, on, &dev->fasync);
inode.c:1207:	struct dev_data		*dev = fd->private_data;
inode.c:1218:	fasync_helper (-1, fd, 0, &dev->fasync);
inode.c:1219:	kfree (dev->buf);
inode.c:1220:	dev->buf = NULL;
inode.c:1224:	dev->state = STATE_DEV_DISABLED;
inode.c:1231:	struct dev_data		*dev = fd->private_data;
inode.c:1232:	struct usb_gadget	*gadget = dev->gadget;
inode.c:1234:	if (gadget->ops->ioctl)
inode.c:1235:		return gadget->ops->ioctl (gadget, code, value);
inode.c:1236:	return -ENOTTY;
inode.c:1252:/*----------------------------------------------------------------------*/
inode.c:1254:/* The in-kernel gadget driver handles most ep0 issues, in particular
inode.c:1270:	desc = dev->dev;
inode.c:1271:	qual.bDeviceClass = desc->bDeviceClass;
inode.c:1272:	qual.bDeviceSubClass = desc->bDeviceSubClass;
inode.c:1273:	qual.bDeviceProtocol = desc->bDeviceProtocol;
inode.c:1276:	qual.bMaxPacketSize0 = desc->bMaxPacketSize0;
inode.c:1281:	memcpy (dev->rbuf, &qual, sizeof qual);
inode.c:1295:		return -EINVAL;
inode.c:1298:	hs = (dev->gadget->speed == USB_SPEED_HIGH);
inode.c:1302:		dev->req->buf = dev->hs_config;
inode.c:1303:		len = le16_to_cpup (&dev->hs_config->wTotalLength);
inode.c:1307:		dev->req->buf = dev->config;
inode.c:1308:		len = le16_to_cpup (&dev->config->wTotalLength);
inode.c:1310:	((u8 *)dev->req->buf) [1] = type;
inode.c:1318:	struct usb_request		*req = dev->req;
inode.c:1319:	int				value = -EOPNOTSUPP;
inode.c:1322:	spin_lock (&dev->lock);
inode.c:1323:	dev->setup_abort = 0;
inode.c:1324:	if (dev->state == STATE_UNCONNECTED) {
inode.c:1328:		dev->state = STATE_CONNECTED;
inode.c:1329:		dev->dev->bMaxPacketSize0 = gadget->ep0->maxpacket;
inode.c:1332:		if (gadget->speed == USB_SPEED_HIGH && dev->hs_config == 0) {
inode.c:1334:			return -EINVAL;
inode.c:1340:		event->u.speed = gadget->speed;
inode.c:1343:		list_for_each_entry (ep, &gadget->ep_list, ep_list) {
inode.c:1344:			data = ep->driver_data;
inode.c:1345:			/* ... down_trylock (&data->lock) ... */
inode.c:1346:			if (data->state != STATE_EP_DEFER_ENABLE)
inode.c:1349:			if (gadget->speed == USB_SPEED_HIGH)
inode.c:1350:				value = usb_ep_enable (ep, &data->hs_desc);
inode.c:1353:				value = usb_ep_enable (ep, &data->desc);
inode.c:1355:				ERROR (dev, "deferred %s enable --> %d\n",
inode.c:1356:					data->name, value);
inode.c:1359:			data->state = STATE_EP_ENABLED;
inode.c:1360:			wake_up (&data->wait);
inode.c:1361:			DBG (dev, "woke up %s waiters\n", data->name);
inode.c:1369:	} else if (dev->state == STATE_SETUP)
inode.c:1370:		dev->setup_abort = 1;
inode.c:1372:	req->buf = dev->rbuf;
inode.c:1373:	req->dma = DMA_ADDR_INVALID;
inode.c:1374:	req->context = NULL;
inode.c:1375:	value = -EOPNOTSUPP;
inode.c:1376:	switch (ctrl->bRequest) {
inode.c:1379:		if (ctrl->bRequestType != USB_DIR_IN)
inode.c:1381:		switch (ctrl->wValue >> 8) {
inode.c:1384:			value = min (ctrl->wLength, (u16) sizeof *dev->dev);
inode.c:1385:			req->buf = dev->dev;
inode.c:1389:			if (!dev->hs_config)
inode.c:1391:			value = min (ctrl->wLength, (u16)
inode.c:1400:					ctrl->wValue >> 8,
inode.c:1401:					ctrl->wValue & 0xff);
inode.c:1403:				value = min (ctrl->wLength, (u16) value);
inode.c:1415:		if (ctrl->bRequestType != 0)
inode.c:1417:		if (0 == (u8) ctrl->wValue) {
inode.c:1419:			dev->current_config = 0;
inode.c:1425:			if (gadget->speed == USB_SPEED_HIGH) {
inode.c:1426:				config = dev->hs_config->bConfigurationValue;
inode.c:1427:				power = dev->hs_config->bMaxPower;
inode.c:1431:				config = dev->config->bConfigurationValue;
inode.c:1432:				power = dev->config->bMaxPower;
inode.c:1435:			if (config == (u8) ctrl->wValue) {
inode.c:1437:				dev->current_config = config;
inode.c:1452:			INFO (dev, "configuration #%d\n", dev->current_config);
inode.c:1453:			if (dev->usermode_setup) {
inode.c:1454:				dev->setup_can_stall = 0;
inode.c:1463:		if (ctrl->bRequestType != 0x80)
inode.c:1465:		*(u8 *)req->buf = dev->current_config;
inode.c:1466:		value = min (ctrl->wLength, (u16) 1);
inode.c:1473:			dev->usermode_setup ? "delegate" : "fail",
inode.c:1474:			ctrl->bRequestType, ctrl->bRequest,
inode.c:1475:			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
inode.c:1478:		if (dev->usermode_setup) {
inode.c:1479:			dev->setup_can_stall = 1;
inode.c:1481:			dev->setup_in = (ctrl->bRequestType & USB_DIR_IN)
inode.c:1483:			dev->setup_out_ready = 0;
inode.c:1484:			dev->setup_out_error = 0;
inode.c:1488:			if (unlikely (!dev->setup_in && ctrl->wLength)) {
inode.c:1489:				value = setup_req (gadget->ep0, dev->req,
inode.c:1490:							ctrl->wLength);
inode.c:1493:				value = usb_ep_queue (gadget->ep0, dev->req,
inode.c:1496:					clean_req (gadget->ep0, dev->req);
inode.c:1501:				dev->setup_can_stall = 0;
inode.c:1506:			event->u.setup = *ctrl;
inode.c:1508:			spin_unlock (&dev->lock);
inode.c:1514:	if (value >= 0 && dev->state != STATE_SETUP) {
inode.c:1515:		req->length = value;
inode.c:1516:		req->zero = value < ctrl->wLength
inode.c:1517:				&& (value % gadget->ep0->maxpacket) == 0;
inode.c:1518:		value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
inode.c:1520:			DBG (dev, "ep_queue --> %d\n", value);
inode.c:1521:			req->status = 0;
inode.c:1526:	spin_unlock (&dev->lock);
inode.c:1534:	DBG (dev, "%s %d\n", __FUNCTION__, dev->state);
inode.c:1536:	/* dev->state must prevent interference */
inode.c:1538:	spin_lock_irq (&dev->lock);
inode.c:1539:	list_for_each_safe (entry, tmp, &dev->epfiles) {
inode.c:1546:		list_del_init (&ep->epfiles);
inode.c:1547:		dentry = ep->dentry;
inode.c:1548:		ep->dentry = NULL;
inode.c:1549:		parent = dentry->d_parent->d_inode;
inode.c:1552:		if (ep->state == STATE_EP_ENABLED)
inode.c:1553:			(void) usb_ep_disable (ep->ep);
inode.c:1554:		ep->state = STATE_EP_UNBOUND;
inode.c:1555:		usb_ep_free_request (ep->ep, ep->req);
inode.c:1556:		ep->ep = NULL;
inode.c:1557:		wake_up (&ep->wait);
inode.c:1560:		spin_unlock_irq (&dev->lock);
inode.c:1563:		down (&parent->i_sem);
inode.c:1566:		up (&parent->i_sem);
inode.c:1571:	spin_unlock_irq (&dev->lock);
inode.c:1584:	gadget_for_each_ep (ep, dev->gadget) {
inode.c:1591:		data->state = STATE_EP_DISABLED;
inode.c:1592:		init_MUTEX (&data->lock);
inode.c:1593:		init_waitqueue_head (&data->wait);
inode.c:1595:		strncpy (data->name, ep->name, sizeof (data->name) - 1);
inode.c:1596:		atomic_set (&data->count, 1);
inode.c:1597:		data->dev = dev;
inode.c:1600:		data->ep = ep;
inode.c:1601:		ep->driver_data = data;
inode.c:1603:		data->req = usb_ep_alloc_request (ep, GFP_KERNEL);
inode.c:1604:		if (!data->req)
inode.c:1607:		data->inode = gadgetfs_create_file (dev->sb, data->name,
inode.c:1609:				&data->dentry);
inode.c:1610:		if (!data->inode) {
inode.c:1614:		list_add_tail (&data->epfiles, &dev->epfiles);
inode.c:1621:	return -ENOMEM;
inode.c:1631:	spin_lock_irq (&dev->lock);
inode.c:1632:	dev->state = STATE_DEV_UNBOUND;
inode.c:1633:	spin_unlock_irq (&dev->lock);
inode.c:1636:	gadget->ep0->driver_data = NULL;
inode.c:1640:	if (dev->req)
inode.c:1641:		usb_ep_free_request (gadget->ep0, dev->req);
inode.c:1654:		return -ESRCH;
inode.c:1655:	if (0 != strcmp (CHIP, gadget->name)) {
inode.c:1657:			shortname, CHIP, gadget->name);
inode.c:1658:		return -ENODEV;
inode.c:1662:	dev->gadget = gadget;
inode.c:1663:	gadget->ep0->driver_data = dev;
inode.c:1664:	dev->dev->bMaxPacketSize0 = gadget->ep0->maxpacket;
inode.c:1667:	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
inode.c:1668:	if (!dev->req)
inode.c:1670:	dev->req->context = NULL;
inode.c:1671:	dev->req->complete = epio_complete;
inode.c:1676:	INFO (dev, "bound to %s driver\n", gadget->name);
inode.c:1677:	dev->state = STATE_UNCONNECTED;
inode.c:1683:	return -ENOMEM;
inode.c:1691:	if (dev->state == STATE_UNCONNECTED) {
inode.c:1695:	dev->state = STATE_UNCONNECTED;
inode.c:1698:	spin_lock (&dev->lock);
inode.c:1701:	spin_unlock (&dev->lock);
inode.c:1709:	INFO (dev, "suspended from state %d\n", dev->state);
inode.c:1710:	spin_lock (&dev->lock);
inode.c:1711:	switch (dev->state) {
inode.c:1721:	spin_unlock (&dev->lock);
inode.c:1745:/*----------------------------------------------------------------------*/
inode.c:1751:	CHIP = gadget->name;
inode.c:1752:	return -EISNAM;
inode.c:1777: *	would change to support features like multi-config devices
inode.c:1781: * 	this one's optional except for high-speed hardware
inode.c:1798:	return config->bDescriptorType == USB_DT_CONFIG
inode.c:1799:		&& config->bLength == USB_DT_CONFIG_SIZE
inode.c:1800:		&& config->bConfigurationValue != 0
inode.c:1801:		&& (config->bmAttributes & USB_CONFIG_ATT_ONE) != 0
inode.c:1802:		&& (config->bmAttributes & USB_CONFIG_ATT_WAKEUP) == 0;
inode.c:1803:	/* FIXME if gadget->is_otg, _must_ include an otg descriptor */
inode.c:1810:	struct dev_data		*dev = fd->private_data;
inode.c:1816:	if (dev->state != STATE_OPENED)
inode.c:1817:		return -EEXIST;
inode.c:1820:		return -EINVAL;
inode.c:1824:		return -EFAULT;
inode.c:1826:		return -EINVAL;
inode.c:1828:	length -= 4;
inode.c:1832:		return -ENOMEM;
inode.c:1835:		return -EFAULT;
inode.c:1838:	spin_lock_irq (&dev->lock);
inode.c:1839:	value = -EINVAL;
inode.c:1840:	if (dev->buf)
inode.c:1842:	dev->buf = kbuf;
inode.c:1845:	dev->config = (void *) kbuf;
inode.c:1846:	total = le16_to_cpup (&dev->config->wTotalLength);
inode.c:1847:	if (!is_valid_config (dev->config) || total >= length)
inode.c:1850:	length -= total;
inode.c:1854:		dev->hs_config = (void *) kbuf;
inode.c:1855:		total = le16_to_cpup (&dev->hs_config->wTotalLength);
inode.c:1856:		if (!is_valid_config (dev->hs_config) || total >= length)
inode.c:1859:		length -= total;
inode.c:1867:	dev->dev = (void *)kbuf;
inode.c:1868:	if (dev->dev->bLength != USB_DT_DEVICE_SIZE
inode.c:1869:			|| dev->dev->bDescriptorType != USB_DT_DEVICE
inode.c:1870:			|| dev->dev->bNumConfigurations != 1)
inode.c:1872:	dev->dev->bNumConfigurations = 1;
inode.c:1873:	dev->dev->bcdUSB = __constant_cpu_to_le16 (0x0200);
inode.c:1876:	spin_unlock_irq (&dev->lock);
inode.c:1879:		kfree (dev->buf);
inode.c:1880:		dev->buf = NULL;
inode.c:1891:		fd->f_op = &ep0_io_operations;
inode.c:1897:	spin_unlock_irq (&dev->lock);
inode.c:1899:	kfree (dev->buf);
inode.c:1900:	dev->buf = NULL;
inode.c:1907:	struct dev_data		*dev = inode->u.generic_ip;
inode.c:1908:	int			value = -EBUSY;
inode.c:1910:	if (dev->state == STATE_DEV_DISABLED) {
inode.c:1911:		dev->ev_next = 0;
inode.c:1912:		dev->state = STATE_OPENED;
inode.c:1913:		fd->private_data = dev;
inode.c:1931:/*----------------------------------------------------------------------*/
inode.c:1961:		inode->i_mode = mode;
inode.c:1962:		inode->i_uid = default_uid;
inode.c:1963:		inode->i_gid = default_gid;
inode.c:1964:		inode->i_blksize = PAGE_CACHE_SIZE;
inode.c:1965:		inode->i_blocks = 0;
inode.c:1966:		inode->i_atime = inode->i_mtime = inode->i_ctime
inode.c:1968:		inode->u.generic_ip = data;
inode.c:1969:		inode->i_fop = fops;
inode.c:1974:/* creates in fs root directory, so non-renamable and non-linkable.
inode.c:1985:	dentry = d_alloc_name(sb->s_root, name);
inode.c:2013:		return -ESRCH;
inode.c:2018:		return -ENODEV;
inode.c:2021:	sb->s_blocksize = PAGE_CACHE_SIZE;
inode.c:2022:	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
inode.c:2023:	sb->s_magic = GADGETFS_MAGIC;
inode.c:2024:	sb->s_op = &gadget_fs_operations;
inode.c:2025:	sb->s_time_gran = 1;
inode.c:2032:		return -ENOMEM;
inode.c:2033:	inode->i_op = &simple_dir_inode_operations;
inode.c:2036:		return -ENOMEM;
inode.c:2038:	sb->s_root = d;
inode.c:2045:		return -ENOMEM;
inode.c:2047:	dev->sb = sb;
inode.c:2050:				&dev->dentry))) {
inode.c:2052:		return -ENOMEM;
inode.c:2062:/* "mount -t gadgetfs path /dev/gadget" ends up here */
inode.c:2080:/*----------------------------------------------------------------------*/
inode.c:2089:/*----------------------------------------------------------------------*/
lh7a40x_udc.c:3: * Sharp LH7A40x on-chip full speed USB device controllers
lh7a40x_udc.c:20: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
lh7a40x_udc.c:44:#ifndef _BIT			/* FIXME - what happended to _BIT in 2.6.7bk18? */
lh7a40x_udc.c:52:static const char ep0name[] = "ep0-control";
lh7a40x_udc.c:124:	volatile u32 *fifo = (volatile u32 *)ep->fifo;
lh7a40x_udc.c:126:	buf = req->req.buf + req->req.actual;
lh7a40x_udc.c:129:	length = req->req.length - req->req.actual;
lh7a40x_udc.c:131:	req->req.actual += length;
lh7a40x_udc.c:136:	while (count--) {
lh7a40x_udc.c:172:/*-------------------------------------------------------------------------*/
lh7a40x_udc.c:221:		      dev->driver ? dev->driver->driver.name : "(none)",
lh7a40x_udc.c:223:	size -= t;
lh7a40x_udc.c:233:	size -= t;
lh7a40x_udc.c:239:	size -= t;
lh7a40x_udc.c:244:	return count - size;
lh7a40x_udc.c:258: * 	udc_disable - disable USB device controller
lh7a40x_udc.c:282:	dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:283:	dev->gadget.speed = USB_SPEED_UNKNOWN;
lh7a40x_udc.c:284:	dev->usb_address = 0;
lh7a40x_udc.c:288: * 	udc_reinit - initialize software state
lh7a40x_udc.c:297:	INIT_LIST_HEAD(&dev->gadget.ep_list);
lh7a40x_udc.c:298:	INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
lh7a40x_udc.c:299:	dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:303:		struct lh7a40x_ep *ep = &dev->ep[i];
lh7a40x_udc.c:306:			list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
lh7a40x_udc.c:308:		ep->desc = 0;
lh7a40x_udc.c:309:		ep->stopped = 0;
lh7a40x_udc.c:310:		INIT_LIST_HEAD(&ep->queue);
lh7a40x_udc.c:311:		ep->pio_irqs = 0;
lh7a40x_udc.c:314:	/* the rest was statically initialized, and is read-only */
lh7a40x_udc.c:329:	dev->gadget.speed = USB_SPEED_UNKNOWN;
lh7a40x_udc.c:354:		struct lh7a40x_ep *ep_reg = &dev->ep[ep];
lh7a40x_udc.c:359:		switch (ep_reg->ep_type) {
lh7a40x_udc.c:363:				  ep_reg->csr2);
lh7a40x_udc.c:371:				  USB_OUT_CSR2_AUTO_CLR, ep_reg->csr2);
lh7a40x_udc.c:378:		csr = usb_read(ep_reg->csr1);
lh7a40x_udc.c:379:		usb_write(csr, ep_reg->csr1);
lh7a40x_udc.c:421:	DEBUG("%s: %s\n", __FUNCTION__, driver->driver.name);
lh7a40x_udc.c:424:	    || driver->speed != USB_SPEED_FULL
lh7a40x_udc.c:425:	    || !driver->bind
lh7a40x_udc.c:426:	    || !driver->unbind || !driver->disconnect || !driver->setup)
lh7a40x_udc.c:427:		return -EINVAL;
lh7a40x_udc.c:429:		return -ENODEV;
lh7a40x_udc.c:430:	if (dev->driver)
lh7a40x_udc.c:431:		return -EBUSY;
lh7a40x_udc.c:434:	dev->driver = driver;
lh7a40x_udc.c:435:	dev->gadget.dev.driver = &driver->driver;
lh7a40x_udc.c:437:	device_add(&dev->gadget.dev);
lh7a40x_udc.c:438:	retval = driver->bind(&dev->gadget);
lh7a40x_udc.c:440:		printk("%s: bind to driver %s --> error %d\n", dev->gadget.name,
lh7a40x_udc.c:441:		       driver->driver.name, retval);
lh7a40x_udc.c:442:		device_del(&dev->gadget.dev);
lh7a40x_udc.c:444:		dev->driver = 0;
lh7a40x_udc.c:445:		dev->gadget.dev.driver = 0;
lh7a40x_udc.c:453:	printk("%s: registered gadget driver '%s'\n", dev->gadget.name,
lh7a40x_udc.c:454:	       driver->driver.name);
lh7a40x_udc.c:472:		return -ENODEV;
lh7a40x_udc.c:473:	if (!driver || driver != dev->driver)
lh7a40x_udc.c:474:		return -EINVAL;
lh7a40x_udc.c:476:	spin_lock_irqsave(&dev->lock, flags);
lh7a40x_udc.c:477:	dev->driver = 0;
lh7a40x_udc.c:479:	spin_unlock_irqrestore(&dev->lock, flags);
lh7a40x_udc.c:481:	driver->unbind(&dev->gadget);
lh7a40x_udc.c:482:	device_del(&dev->gadget.dev);
lh7a40x_udc.c:486:	DEBUG("unregistered gadget driver '%s'\n", driver->driver.name);
lh7a40x_udc.c:492:/*-------------------------------------------------------------------------*/
lh7a40x_udc.c:503:	max = le16_to_cpu(ep->desc->wMaxPacketSize);
lh7a40x_udc.c:505:	csr = usb_read(ep->csr1);
lh7a40x_udc.c:513:		usb_set(USB_IN_CSR1_IN_PKT_RDY, ep->csr1);
lh7a40x_udc.c:519:			if (likely(req->req.length != req->req.actual)
lh7a40x_udc.c:520:			    || req->req.zero)
lh7a40x_udc.c:529:		      ep->ep.name, count,
lh7a40x_udc.c:531:		      req->req.length - req->req.actual, req);
lh7a40x_udc.c:536:			if (list_empty(&ep->queue)) {
lh7a40x_udc.c:557:	volatile u32 *fifo = (volatile u32 *)ep->fifo;
lh7a40x_udc.c:560:	csr = usb_read(ep->csr1);
lh7a40x_udc.c:563:		return -EINVAL;
lh7a40x_udc.c:566:	buf = req->req.buf + req->req.actual;
lh7a40x_udc.c:568:	bufferspace = req->req.length - req->req.actual;
lh7a40x_udc.c:572:	req->req.actual += min(count, bufferspace);
lh7a40x_udc.c:574:	is_short = (count < ep->ep.maxpacket);
lh7a40x_udc.c:576:	      ep->ep.name, csr, count,
lh7a40x_udc.c:577:	      is_short ? "/S" : "", req, req->req.actual, req->req.length);
lh7a40x_udc.c:579:	while (likely(count-- != 0)) {
lh7a40x_udc.c:587:			if (req->req.status != -EOVERFLOW)
lh7a40x_udc.c:588:				printk("%s overflow %d\n", ep->ep.name, count);
lh7a40x_udc.c:589:			req->req.status = -EOVERFLOW;
lh7a40x_udc.c:592:			bufferspace--;
lh7a40x_udc.c:596:	usb_clear(USB_OUT_CSR1_OUT_PKT_RDY, ep->csr1);
lh7a40x_udc.c:599:	if (is_short || req->req.actual == req->req.length) {
lh7a40x_udc.c:601:		usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
lh7a40x_udc.c:603:		if (list_empty(&ep->queue))
lh7a40x_udc.c:613: *	done - retire a request; caller blocked irqs
lh7a40x_udc.c:618:	unsigned int stopped = ep->stopped;
lh7a40x_udc.c:622:	list_del_init(&req->queue);
lh7a40x_udc.c:624:	if (likely(req->req.status == -EINPROGRESS))
lh7a40x_udc.c:625:		req->req.status = status;
lh7a40x_udc.c:627:		status = req->req.status;
lh7a40x_udc.c:629:	if (status && status != -ESHUTDOWN)
lh7a40x_udc.c:631:		      ep->ep.name, &req->req, status,
lh7a40x_udc.c:632:		      req->req.actual, req->req.length);
lh7a40x_udc.c:635:	ep->stopped = 1;
lh7a40x_udc.c:639:	spin_unlock(&ep->dev->lock);
lh7a40x_udc.c:640:	req->req.complete(&ep->ep, &req->req);
lh7a40x_udc.c:641:	spin_lock(&ep->dev->lock);
lh7a40x_udc.c:645:	ep->stopped = stopped;
lh7a40x_udc.c:691: * 	nuke - dequeue ALL requests
lh7a40x_udc.c:703:	while (!list_empty(&ep->queue)) {
lh7a40x_udc.c:704:		req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
lh7a40x_udc.c:709:	if (ep->desc)
lh7a40x_udc.c:718:		struct lh7a40x_ep *ep = &dev->ep[n];
lh7a40x_udc.c:730:		struct lh7a40x_ep *ep = &dev->ep[n];
lh7a40x_udc.c:743:	switch (ep->ep_type) {
lh7a40x_udc.c:751:		usb_set(USB_IN_CSR1_FIFO_FLUSH, ep->csr1);
lh7a40x_udc.c:756:		usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1);
lh7a40x_udc.c:762: * lh7a40x_in_epn - handle IN interrupt
lh7a40x_udc.c:767:	struct lh7a40x_ep *ep = &dev->ep[ep_idx];
lh7a40x_udc.c:772:	csr = usb_read(ep->csr1);
lh7a40x_udc.c:778:			ep->csr1);
lh7a40x_udc.c:782:	if (!ep->desc) {
lh7a40x_udc.c:787:	if (list_empty(&ep->queue))
lh7a40x_udc.c:790:		req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
lh7a40x_udc.c:806:	struct lh7a40x_ep *ep = &dev->ep[ep_idx];
lh7a40x_udc.c:813:	if (ep->desc) {
lh7a40x_udc.c:815:		csr = usb_read(ep->csr1);
lh7a40x_udc.c:818:			usb_read(ep->
lh7a40x_udc.c:826:				/* usb_set(USB_OUT_CSR1_FIFO_FLUSH, ep->csr1); */
lh7a40x_udc.c:829:				if (list_empty(&ep->queue))
lh7a40x_udc.c:833:					    list_entry(ep->queue.next,
lh7a40x_udc.c:862:	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
lh7a40x_udc.c:864:	dev->gadget.speed = USB_SPEED_UNKNOWN;
lh7a40x_udc.c:868:		struct lh7a40x_ep *ep = &dev->ep[i];
lh7a40x_udc.c:869:		ep->stopped = 1;
lh7a40x_udc.c:872:		nuke(ep, -ESHUTDOWN);
lh7a40x_udc.c:877:		spin_unlock(&dev->lock);
lh7a40x_udc.c:878:		driver->disconnect(&dev->gadget);
lh7a40x_udc.c:879:		spin_lock(&dev->lock);
lh7a40x_udc.c:882:	/* re-init driver-visible data structures */
lh7a40x_udc.c:893:	DEBUG("%s: %d\n", __FUNCTION__, dev->usb_address);
lh7a40x_udc.c:895:	if (!dev->usb_address) {
lh7a40x_udc.c:913:	/* Re-enable UDC */
lh7a40x_udc.c:917:	dev->gadget.speed = USB_SPEED_FULL;
lh7a40x_udc.c:929:	spin_lock(&dev->lock);
lh7a40x_udc.c:944:		      state_names[dev->ep0state]);
lh7a40x_udc.c:988:				if (dev->gadget.speed != USB_SPEED_UNKNOWN
lh7a40x_udc.c:989:				    && dev->driver
lh7a40x_udc.c:990:				    && dev->driver->resume
lh7a40x_udc.c:992:					dev->driver->resume(&dev->gadget);
lh7a40x_udc.c:1000:					stop_activity(dev, dev->driver);
lh7a40x_udc.c:1001:				} else if (dev->gadget.speed !=
lh7a40x_udc.c:1002:					   USB_SPEED_UNKNOWN && dev->driver
lh7a40x_udc.c:1003:					   && dev->driver->suspend) {
lh7a40x_udc.c:1004:					dev->driver->suspend(&dev->gadget);
lh7a40x_udc.c:1011:	spin_unlock(&dev->lock);
lh7a40x_udc.c:1026:	if (!_ep || !desc || ep->desc || _ep->name == ep0name
lh7a40x_udc.c:1027:	    || desc->bDescriptorType != USB_DT_ENDPOINT
lh7a40x_udc.c:1028:	    || ep->bEndpointAddress != desc->bEndpointAddress
lh7a40x_udc.c:1029:	    || ep_maxpacket(ep) < le16_to_cpu(desc->wMaxPacketSize)) {
lh7a40x_udc.c:1031:		return -EINVAL;
lh7a40x_udc.c:1035:	if (ep->bmAttributes != desc->bmAttributes
lh7a40x_udc.c:1036:	    && ep->bmAttributes != USB_ENDPOINT_XFER_BULK
lh7a40x_udc.c:1037:	    && desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
lh7a40x_udc.c:1038:		DEBUG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
lh7a40x_udc.c:1039:		return -EINVAL;
lh7a40x_udc.c:1043:	if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
lh7a40x_udc.c:1044:	     && le16_to_cpu(desc->wMaxPacketSize) != ep_maxpacket(ep))
lh7a40x_udc.c:1045:	    || !desc->wMaxPacketSize) {
lh7a40x_udc.c:1046:		DEBUG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
lh7a40x_udc.c:1047:		return -ERANGE;
lh7a40x_udc.c:1050:	dev = ep->dev;
lh7a40x_udc.c:1051:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
lh7a40x_udc.c:1053:		return -ESHUTDOWN;
lh7a40x_udc.c:1056:	spin_lock_irqsave(&ep->dev->lock, flags);
lh7a40x_udc.c:1058:	ep->stopped = 0;
lh7a40x_udc.c:1059:	ep->desc = desc;
lh7a40x_udc.c:1060:	ep->pio_irqs = 0;
lh7a40x_udc.c:1061:	ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
lh7a40x_udc.c:1066:	spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1068:	DEBUG("%s: enabled %s\n", __FUNCTION__, _ep->name);
lh7a40x_udc.c:1083:	if (!_ep || !ep->desc) {
lh7a40x_udc.c:1085:		      _ep ? ep->ep.name : NULL);
lh7a40x_udc.c:1086:		return -EINVAL;
lh7a40x_udc.c:1089:	spin_lock_irqsave(&ep->dev->lock, flags);
lh7a40x_udc.c:1094:	nuke(ep, -ESHUTDOWN);
lh7a40x_udc.c:1099:	ep->desc = 0;
lh7a40x_udc.c:1100:	ep->stopped = 1;
lh7a40x_udc.c:1102:	spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1104:	DEBUG("%s: disabled %s\n", __FUNCTION__, _ep->name);
lh7a40x_udc.c:1120:	INIT_LIST_HEAD(&req->queue);
lh7a40x_udc.c:1122:	return &req->req;
lh7a40x_udc.c:1132:	WARN_ON(!list_empty(&req->queue));
lh7a40x_udc.c:1172:	    (!_req || !_req->complete || !_req->buf
lh7a40x_udc.c:1173:	     || !list_empty(&req->queue))) {
lh7a40x_udc.c:1175:		return -EINVAL;
lh7a40x_udc.c:1179:	if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
lh7a40x_udc.c:1181:		return -EINVAL;
lh7a40x_udc.c:1184:	dev = ep->dev;
lh7a40x_udc.c:1185:	if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
lh7a40x_udc.c:1186:		DEBUG("%s, bogus device state %p\n", __FUNCTION__, dev->driver);
lh7a40x_udc.c:1187:		return -ESHUTDOWN;
lh7a40x_udc.c:1190:	DEBUG("%s queue req %p, len %d buf %p\n", _ep->name, _req, _req->length,
lh7a40x_udc.c:1191:	      _req->buf);
lh7a40x_udc.c:1193:	spin_lock_irqsave(&dev->lock, flags);
lh7a40x_udc.c:1195:	_req->status = -EINPROGRESS;
lh7a40x_udc.c:1196:	_req->actual = 0;
lh7a40x_udc.c:1199:	DEBUG("Add to %d Q %d %d\n", ep_index(ep), list_empty(&ep->queue),
lh7a40x_udc.c:1200:	      ep->stopped);
lh7a40x_udc.c:1201:	if (list_empty(&ep->queue) && likely(!ep->stopped)) {
lh7a40x_udc.c:1206:			list_add_tail(&req->queue, &ep->queue);
lh7a40x_udc.c:1212:			csr = usb_read(ep->csr1);
lh7a40x_udc.c:1221:			csr = usb_read(ep->csr1);
lh7a40x_udc.c:1232:		list_add_tail(&req->queue, &ep->queue);
lh7a40x_udc.c:1234:	spin_unlock_irqrestore(&dev->lock, flags);
lh7a40x_udc.c:1249:	if (!_ep || ep->ep.name == ep0name)
lh7a40x_udc.c:1250:		return -EINVAL;
lh7a40x_udc.c:1252:	spin_lock_irqsave(&ep->dev->lock, flags);
lh7a40x_udc.c:1255:	list_for_each_entry(req, &ep->queue, queue) {
lh7a40x_udc.c:1256:		if (&req->req == _req)
lh7a40x_udc.c:1259:	if (&req->req != _req) {
lh7a40x_udc.c:1260:		spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1261:		return -EINVAL;
lh7a40x_udc.c:1264:	done(ep, req, -ECONNRESET);
lh7a40x_udc.c:1266:	spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1280:	if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
lh7a40x_udc.c:1282:		return -EINVAL;
lh7a40x_udc.c:1289:	spin_lock_irqsave(&ep->dev->lock, flags);
lh7a40x_udc.c:1293:		usb_set(EP0_SEND_STALL, ep->csr1);
lh7a40x_udc.c:1295:		u32 csr = usb_read(ep->csr1);
lh7a40x_udc.c:1297:			      || !list_empty(&ep->queue))) {
lh7a40x_udc.c:1299:			 * Attempts to halt IN endpoints will fail (returning -EAGAIN)
lh7a40x_udc.c:1303:			spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1305:			    ("Attempt to halt IN endpoint failed (returning -EAGAIN) %d %d\n",
lh7a40x_udc.c:1307:			     !list_empty(&ep->queue));
lh7a40x_udc.c:1308:			return -EAGAIN;
lh7a40x_udc.c:1312:			usb_set(USB_IN_CSR1_SEND_STALL, ep->csr1);
lh7a40x_udc.c:1314:			usb_clear(USB_IN_CSR1_SEND_STALL, ep->csr1);
lh7a40x_udc.c:1315:			usb_set(USB_IN_CSR1_CLR_DATA_TOGGLE, ep->csr1);
lh7a40x_udc.c:1322:			usb_set(USB_OUT_CSR1_SEND_STALL, ep->csr1);
lh7a40x_udc.c:1324:			usb_clear(USB_OUT_CSR1_SEND_STALL, ep->csr1);
lh7a40x_udc.c:1325:			usb_set(USB_OUT_CSR1_CLR_DATA_REG, ep->csr1);
lh7a40x_udc.c:1330:		ep->stopped = 1;
lh7a40x_udc.c:1332:		ep->stopped = 0;
lh7a40x_udc.c:1335:	spin_unlock_irqrestore(&ep->dev->lock, flags);
lh7a40x_udc.c:1337:	DEBUG("%s %s halted\n", _ep->name, value == 0 ? "NOT" : "IS");
lh7a40x_udc.c:1354:		return -ENODEV;
lh7a40x_udc.c:1361:		return -EOPNOTSUPP;
lh7a40x_udc.c:1365:	csr = usb_read(ep->csr1);
lh7a40x_udc.c:1366:	if (ep->dev->gadget.speed != USB_SPEED_UNKNOWN ||
lh7a40x_udc.c:1382:	if (unlikely(!_ep || (!ep->desc && ep->ep.name != ep0name))) {
lh7a40x_udc.c:1412:		if (likely(req->req.length != req->req.actual) || req->req.zero)
lh7a40x_udc.c:1419:		  ep->ep.name, count,
lh7a40x_udc.c:1420:		  is_last ? "/L" : "", req->req.length - req->req.actual, req);
lh7a40x_udc.c:1436:	volatile u32 *fifo = (volatile u32 *)ep->fifo;
lh7a40x_udc.c:1441:	while (count--)
lh7a40x_udc.c:1449:	volatile u32 *fifo = (volatile u32 *)ep->fifo;
lh7a40x_udc.c:1451:	while (count--)
lh7a40x_udc.c:1460:	volatile u32 *fifo = (volatile u32 *)ep->fifo;
lh7a40x_udc.c:1468:	buf = req->req.buf + req->req.actual;
lh7a40x_udc.c:1470:	bufferspace = req->req.length - req->req.actual;
lh7a40x_udc.c:1475:		req->req.actual += min(count, bufferspace);
lh7a40x_udc.c:1479:	is_short = (count < ep->ep.maxpacket);
lh7a40x_udc.c:1481:		  ep->ep.name, csr, count,
lh7a40x_udc.c:1482:		  is_short ? "/S" : "", req, req->req.actual, req->req.length);
lh7a40x_udc.c:1484:	while (likely(count-- != 0)) {
lh7a40x_udc.c:1492:			if (req->req.status != -EOVERFLOW)
lh7a40x_udc.c:1493:				DEBUG_EP0("%s overflow %d\n", ep->ep.name,
lh7a40x_udc.c:1495:			req->req.status = -EOVERFLOW;
lh7a40x_udc.c:1498:			bufferspace--;
lh7a40x_udc.c:1503:	if (is_short || req->req.actual == req->req.length) {
lh7a40x_udc.c:1513: * udc_set_address - set the USB address for this device
lh7a40x_udc.c:1521:	/* c.f. 15.1.2.2 Table 15-4 address will be used after DATA_END is set */
lh7a40x_udc.c:1522:	dev->usb_address = address;
lh7a40x_udc.c:1530: *      - if error
lh7a40x_udc.c:1532: *      - else
lh7a40x_udc.c:1539:	struct lh7a40x_ep *ep = &dev->ep[0];
lh7a40x_udc.c:1544:	if (list_empty(&ep->queue))
lh7a40x_udc.c:1547:		req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
lh7a40x_udc.c:1551:		if (req->req.length == 0) {
lh7a40x_udc.c:1554:			dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1564:			dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1581:	struct lh7a40x_ep *ep = &dev->ep[0];
lh7a40x_udc.c:1586:	if (list_empty(&ep->queue))
lh7a40x_udc.c:1589:		req = list_entry(ep->queue.next, struct lh7a40x_request, queue);
lh7a40x_udc.c:1596:	if (req->req.length == 0) {
lh7a40x_udc.c:1599:		dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1603:	if (req->req.length - req->req.actual == EP0_PACKETSIZE) {
lh7a40x_udc.c:1605:		/* so we need Zero-length-packet */
lh7a40x_udc.c:1616:		dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1625:		dev->ep0state = DATA_STATE_NEED_ZLP;
lh7a40x_udc.c:1634:	struct lh7a40x_ep *ep0 = &dev->ep[0];
lh7a40x_udc.c:1636:	int reqtype = (ctrl->bRequestType & USB_RECIP_MASK);
lh7a40x_udc.c:1650:		int ep_num = (ctrl->wIndex & ~USB_DIR_IN);
lh7a40x_udc.c:1653:		    ("GET_STATUS: USB_RECIP_ENDPOINT (%d), ctrl->wLength = %d\n",
lh7a40x_udc.c:1654:		     ep_num, ctrl->wLength);
lh7a40x_udc.c:1656:		if (ctrl->wLength > 2 || ep_num > 3)
lh7a40x_udc.c:1657:			return -EOPNOTSUPP;
lh7a40x_udc.c:1659:		qep = &dev->ep[ep_num];
lh7a40x_udc.c:1660:		if (ep_is_in(qep) != ((ctrl->wIndex & USB_DIR_IN) ? 1 : 0)
lh7a40x_udc.c:1662:			return -EOPNOTSUPP;
lh7a40x_udc.c:1668:		switch (qep->ep_type) {
lh7a40x_udc.c:1671:			    (usb_read(qep->csr1) & EP0_SEND_STALL) ==
lh7a40x_udc.c:1677:			    (usb_read(qep->csr1) & USB_IN_CSR1_SEND_STALL) ==
lh7a40x_udc.c:1682:			    (usb_read(qep->csr1) & USB_OUT_CSR1_SEND_STALL) ==
lh7a40x_udc.c:1691:			    ctrl->wIndex, val);
lh7a40x_udc.c:1694:		return -EOPNOTSUPP;
lh7a40x_udc.c:1709: *      - read data packet from EP0 FIFO
lh7a40x_udc.c:1710: *      - decode command
lh7a40x_udc.c:1711: *      - if error
lh7a40x_udc.c:1713: *      - else
lh7a40x_udc.c:1718:	struct lh7a40x_ep *ep = &dev->ep[0];
lh7a40x_udc.c:1725:	nuke(ep, -EPROTO);
lh7a40x_udc.c:1740:		ep->bEndpointAddress |= USB_DIR_IN;
lh7a40x_udc.c:1743:		ep->bEndpointAddress &= ~USB_DIR_IN;
lh7a40x_udc.c:1747:	dev->req_pending = 1;
lh7a40x_udc.c:1775:				qep = &dev->ep[ep_num];
lh7a40x_udc.c:1779:					lh7a40x_set_halt(&qep->ep, 1);
lh7a40x_udc.c:1783:					lh7a40x_set_halt(&qep->ep, 0);
lh7a40x_udc.c:1799:	if (likely(dev->driver)) {
lh7a40x_udc.c:1800:		/* device-2-host (IN) or no data setup command, process immediately */
lh7a40x_udc.c:1801:		spin_unlock(&dev->lock);
lh7a40x_udc.c:1802:		i = dev->driver->setup(&dev->gadget, &ctrl);
lh7a40x_udc.c:1803:		spin_lock(&dev->lock);
lh7a40x_udc.c:1808:			    ("  --> ERROR: gadget setup FAILED (stalling), setup returned %d\n",
lh7a40x_udc.c:1814:			/* ep->stopped = 1; */
lh7a40x_udc.c:1815:			dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1827:	/* c.f. Table 15-14 */
lh7a40x_udc.c:1829:	dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1837:	struct lh7a40x_ep *ep = &dev->ep[0];
lh7a40x_udc.c:1855:	 *      - clear the SENT_STALL bit
lh7a40x_udc.c:1860:		nuke(ep, -ECONNABORTED);
lh7a40x_udc.c:1861:		dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1867:	 *      - fill EP0 FIFO
lh7a40x_udc.c:1868:	 *      - if last packet
lh7a40x_udc.c:1869:	 *      -       set IN_PKT_RDY | DATA_END
lh7a40x_udc.c:1870:	 *      - else
lh7a40x_udc.c:1877:		switch (dev->ep0state) {
lh7a40x_udc.c:1889:				  state_names[dev->ep0state]);
lh7a40x_udc.c:1890:			dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1892:			/* usb_set(EP0_SEND_STALL, ep->csr1); */
lh7a40x_udc.c:1899:	 *      - abort the last transfer
lh7a40x_udc.c:1900:	 *      - set SERVICED_SETUP_END_BIT
lh7a40x_udc.c:1908:		dev->ep0state = WAIT_FOR_SETUP;
lh7a40x_udc.c:1913:	 *      - read data packet from EP0 FIFO
lh7a40x_udc.c:1914:	 *      - decode command
lh7a40x_udc.c:1915:	 *      - if error
lh7a40x_udc.c:1917:	 *      - else
lh7a40x_udc.c:1925:		switch (dev->ep0state) {
lh7a40x_udc.c:1939:				  dev->ep0state);
lh7a40x_udc.c:1958:		dev->ep0state = DATA_STATE_XMIT;
lh7a40x_udc.c:1961:		dev->ep0state = DATA_STATE_RECV;
lh7a40x_udc.c:1966:/* ---------------------------------------------------------------------------
lh7a40x_udc.c:1967: * 	device-scoped parts of the api to the usb controller hardware
lh7a40x_udc.c:1968: * ---------------------------------------------------------------------------
lh7a40x_udc.c:1983:	   return -EHOSTUNREACH;
lh7a40x_udc.c:1985:	return -ENOTSUPP;
lh7a40x_udc.c:1991:	/* current versions must always be self-powered */
lh7a40x_udc.c:1996:	DEBUG("%s %s\n", __FUNCTION__, dev->bus_id);
lh7a40x_udc.c:2033:			 .name = "ep1in-bulk",
lh7a40x_udc.c:2050:			 .name = "ep2out-bulk",
lh7a40x_udc.c:2067:			 .name = "ep3in-int",
lh7a40x_udc.c:2084: * 	probe - binds to the platform device
lh7a40x_udc.c:2093:	spin_lock_init(&dev->lock);
lh7a40x_udc.c:2094:	dev->dev = _dev;
lh7a40x_udc.c:2096:	device_initialize(&dev->gadget.dev);
lh7a40x_udc.c:2097:	dev->gadget.dev.parent = _dev;
lh7a40x_udc.c:2112:		return -EBUSY;
lh7a40x_udc.c:2122:	struct lh7a40x_udc *dev = _dev->driver_data;
lh7a40x_udc.c:2128:	usb_gadget_unregister_driver(dev->driver);
lh7a40x_udc.c:2139:/*-------------------------------------------------------------------------*/
lh7a40x_udc.c:2148:	    /* .resume = ... re-enable UDC */
net2280.c:16: * short OUT transfers happen.)  Drivers can use the req->no_interrupt
net2280.c:40: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
net2280.c:87:	"ep-a", "ep-b", "ep-c", "ep-d",
net2280.c:88:	"ep-e", "ep-f",
net2280.c:91:/* use_dma -- general goodness, fewer interrupts, less cpu load (vs PIO)
net2280.c:92: * use_dma_chaining -- dma descriptor queueing gives even more irq reduction
net2280.c:107:/* mode 0 == ep-{a,b,c,d} 1K fifo each
net2280.c:108: * mode 1 == ep-{a,b} 2K fifo each, ep-{c,d} unavailable
net2280.c:109: * mode 2 == ep-a 2K fifo, ep-{b,c} 1K each, ep-d unavailable
net2280.c:136:/*-------------------------------------------------------------------------*/
net2280.c:147:	if (!_ep || !desc || ep->desc || _ep->name == ep0name
net2280.c:148:			|| desc->bDescriptorType != USB_DT_ENDPOINT)
net2280.c:149:		return -EINVAL;
net2280.c:150:	dev = ep->dev;
net2280.c:151:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:152:		return -ESHUTDOWN;
net2280.c:155:	if ((desc->bEndpointAddress & 0x0f) == EP_DONTUSE)
net2280.c:156:		return -EDOM;
net2280.c:158:	/* sanity check ep-e/ep-f since their fifos are small */
net2280.c:159:	max = le16_to_cpu (desc->wMaxPacketSize) & 0x1fff;
net2280.c:160:	if (ep->num > 4 && max > 64)
net2280.c:161:		return -ERANGE;
net2280.c:163:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:164:	_ep->maxpacket = max & 0x7ff;
net2280.c:165:	ep->desc = desc;
net2280.c:168:	ep->stopped = 0;
net2280.c:169:	ep->out_overflow = 0;
net2280.c:171:	/* set speed-dependent max packet; may kick in high bandwidth */
net2280.c:172:	set_idx_reg (dev->regs, REG_EP_MAXPKT (dev, ep->num), max);
net2280.c:175:	 * use it instead of troublesome (non-bulk) multi-packet DMA.
net2280.c:177:	if (ep->dma && (max % 4) != 0 && use_dma_chaining) {
net2280.c:178:		DEBUG (ep->dev, "%s, no dma for maxpacket %d\n",
net2280.c:179:			ep->ep.name, ep->ep.maxpacket);
net2280.c:180:		ep->dma = NULL;
net2280.c:184:	writel ((1 << FIFO_FLUSH), &ep->regs->ep_stat);
net2280.c:185:	tmp = (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
net2280.c:188:		if (dev->chiprev == 0100
net2280.c:189:				&& dev->gadget.speed == USB_SPEED_HIGH
net2280.c:190:				&& !(desc->bEndpointAddress & USB_DIR_IN))
net2280.c:192:				&ep->regs->ep_rsp);
net2280.c:195:		if ((dev->gadget.speed == USB_SPEED_HIGH
net2280.c:197:				|| (dev->gadget.speed == USB_SPEED_FULL
net2280.c:199:			spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:200:			return -ERANGE;
net2280.c:203:	ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC) ? 1 : 0;
net2280.c:205:	tmp |= desc->bEndpointAddress;
net2280.c:211:	ep->is_in = (tmp & USB_DIR_IN) != 0;
net2280.c:212:	if (!ep->is_in)
net2280.c:213:		writel ((1 << SET_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
net2280.c:215:	writel (tmp, &ep->regs->ep_cfg);
net2280.c:218:	if (!ep->dma) {				/* pio, per-packet */
net2280.c:219:		tmp = (1 << ep->num) | readl (&dev->regs->pciirqenb0);
net2280.c:220:		writel (tmp, &dev->regs->pciirqenb0);
net2280.c:224:			| readl (&ep->regs->ep_irqenb);
net2280.c:225:		writel (tmp, &ep->regs->ep_irqenb);
net2280.c:226:	} else {				/* dma, per-request */
net2280.c:227:		tmp = (1 << (8 + ep->num));	/* completion */
net2280.c:228:		tmp |= readl (&dev->regs->pciirqenb1);
net2280.c:229:		writel (tmp, &dev->regs->pciirqenb1);
net2280.c:232:		 * advance the queue; do it pio-style, by hand.
net2280.c:235:		if ((desc->bEndpointAddress & USB_DIR_IN) == 0) {
net2280.c:237:			writel (tmp, &ep->regs->ep_irqenb);
net2280.c:239:			tmp = (1 << ep->num) | readl (&dev->regs->pciirqenb0);
net2280.c:240:			writel (tmp, &dev->regs->pciirqenb0);
net2280.c:244:	tmp = desc->bEndpointAddress;
net2280.c:245:	DEBUG (dev, "enabled %s (ep%d%s-%s) %s max %04x\n",
net2280.c:246:		_ep->name, tmp & 0x0f, DIR_STRING (tmp),
net2280.c:247:		type_string (desc->bmAttributes),
net2280.c:248:		ep->dma ? "dma" : "pio", max);
net2280.c:251:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:262:			return -ENODEV;
net2280.c:267:		usec--;
net2280.c:269:	return -ETIMEDOUT;
net2280.c:278:	ep->desc = NULL;
net2280.c:279:	INIT_LIST_HEAD (&ep->queue);
net2280.c:281:	ep->ep.maxpacket = ~0;
net2280.c:282:	ep->ep.ops = &net2280_ep_ops;
net2280.c:285:	if (ep->dma) {
net2280.c:286:		writel (0, &ep->dma->dmactl);
net2280.c:290:			, &ep->dma->dmastat);
net2280.c:292:		tmp = readl (&regs->pciirqenb0);
net2280.c:293:		tmp &= ~(1 << ep->num);
net2280.c:294:		writel (tmp, &regs->pciirqenb0);
net2280.c:296:		tmp = readl (&regs->pciirqenb1);
net2280.c:297:		tmp &= ~(1 << (8 + ep->num));	/* completion */
net2280.c:298:		writel (tmp, &regs->pciirqenb1);
net2280.c:300:	writel (0, &ep->regs->ep_irqenb);
net2280.c:310:	if (ep->num != 0) {
net2280.c:314:	writel (tmp, &ep->regs->ep_rsp);
net2280.c:332:		, &ep->regs->ep_stat);
net2280.c:345:	if (!_ep || !ep->desc || _ep->name == ep0name)
net2280.c:346:		return -EINVAL;
net2280.c:348:	spin_lock_irqsave (&ep->dev->lock, flags);
net2280.c:350:	ep_reset (ep->dev->regs, ep);
net2280.c:352:	VDEBUG (ep->dev, "disabled %s %s\n",
net2280.c:353:			ep->dma ? "dma" : "pio", _ep->name);
net2280.c:356:	(void) readl (&ep->regs->ep_cfg);
net2280.c:358:	if (use_dma && !ep->dma && ep->num >= 1 && ep->num <= 4)
net2280.c:359:		ep->dma = &ep->dev->dma [ep->num - 1];
net2280.c:361:	spin_unlock_irqrestore (&ep->dev->lock, flags);
net2280.c:365:/*-------------------------------------------------------------------------*/
net2280.c:382:	req->req.dma = DMA_ADDR_INVALID;
net2280.c:383:	INIT_LIST_HEAD (&req->queue);
net2280.c:386:	if (ep->dma) {
net2280.c:389:		td = pci_pool_alloc (ep->dev->requests, gfp_flags,
net2280.c:390:				&req->td_dma);
net2280.c:395:		td->dmacount = 0;	/* not VALID */
net2280.c:396:		td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
net2280.c:397:		td->dmadesc = td->dmaaddr;
net2280.c:398:		req->td = td;
net2280.c:400:	return &req->req;
net2280.c:414:	WARN_ON (!list_empty (&req->queue));
net2280.c:415:	if (req->td)
net2280.c:416:		pci_pool_free (ep->dev->requests, req->td, req->td_dma);
net2280.c:420:/*-------------------------------------------------------------------------*/
net2280.c:424:/* many common platforms have dma-coherent caches, which means that it's
net2280.c:427: * between dma and non-dma activities, which is a slow idea in any case.)
net2280.c:443:/* FIXME there are other cases, including an x86-64 one ...  */
net2280.c:447: * on some platforms will mean eliminating a per-io buffer copy.  with
net2280.c:471:	if (ep->dma) {
net2280.c:473:		 * on typical 1/N page allocations: it allocates 1-N pages.
net2280.c:476:		retval = dma_alloc_coherent(&ep->dev->pdev->dev,
net2280.c:499:		dma_free_coherent(&ep->dev->pdev->dev, bytes, buf, dma);
net2280.c:505:/*-------------------------------------------------------------------------*/
net2280.c:510: * NOTE: pio with ep-a..ep-d could stuff multiple packets into the fifo
net2280.c:512: * one packet.  ep-a..ep-d should use dma instead.
net2280.c:517:	struct net2280_ep_regs	__iomem *regs = ep->regs;
net2280.c:525:		buf = req->buf + req->actual;
net2280.c:527:		total = req->length - req->actual;
net2280.c:534:	count = ep->ep.maxpacket;
net2280.c:538:	VDEBUG (ep->dev, "write %s fifo (IN) %d bytes%s req %p\n",
net2280.c:539:			ep->ep.name, count,
net2280.c:540:			(count != ep->ep.maxpacket) ? " (short)" : "",
net2280.c:549:		writel (tmp, &regs->ep_data);
net2280.c:551:		count -= 4;
net2280.c:558:	if (count || total < ep->ep.maxpacket) {
net2280.c:562:		writel (tmp, &regs->ep_data);
net2280.c:582:	statp = &ep->regs->ep_stat;
net2280.c:591:			&& ep->dev->gadget.speed == USB_SPEED_FULL) {
net2280.c:605: * for ep-a..ep-d this will read multiple packets out when they
net2280.c:611:	struct net2280_ep_regs	__iomem *regs = ep->regs;
net2280.c:612:	u8			*buf = req->req.buf + req->req.actual;
net2280.c:619:	if (ep->dev->chiprev == 0x0100
net2280.c:620:			&& ep->dev->gadget.speed == USB_SPEED_FULL) {
net2280.c:622:		tmp = readl (&ep->regs->ep_stat);
net2280.c:636:	count = readl (&regs->ep_avail);
net2280.c:639:		tmp = readl (&ep->regs->ep_stat);
net2280.c:640:		count = readl (&regs->ep_avail);
net2280.c:646:	tmp = req->req.length - req->req.actual;
net2280.c:649:		if ((tmp % ep->ep.maxpacket) != 0) {
net2280.c:650:			ERROR (ep->dev,
net2280.c:652:				ep->ep.name, count, tmp);
net2280.c:653:			req->req.status = -EOVERFLOW;
net2280.c:661:	req->req.actual += count;
net2280.c:663:	is_short = (count == 0) || ((count % ep->ep.maxpacket) != 0);
net2280.c:665:	VDEBUG (ep->dev, "read %s fifo (OUT) %d bytes%s%s%s req %p %d/%d\n",
net2280.c:666:			ep->ep.name, count, is_short ? " (short)" : "",
net2280.c:668:			req, req->req.actual, req->req.length);
net2280.c:671:		tmp = readl (&regs->ep_data);
net2280.c:675:		count -= 4;
net2280.c:678:		tmp = readl (&regs->ep_data);
net2280.c:683:		} while (--count);
net2280.c:688:		writel ((1 << CLEAR_NAK_OUT_PACKETS), &ep->regs->ep_rsp);
net2280.c:689:		(void) readl (&ep->regs->ep_rsp);
net2280.c:692:	return is_short || ((req->req.actual == req->req.length)
net2280.c:693:				&& !req->req.zero);
net2280.c:700:	struct net2280_dma	*td = req->td;
net2280.c:701:	u32			dmacount = req->req.length;
net2280.c:705:	 * in case of overruns on max-size packets, we can't
net2280.c:708:	if (ep->is_in)
net2280.c:710:	else if ((dmacount % ep->ep.maxpacket) != 0)
net2280.c:713:	req->valid = valid;
net2280.c:716:	if (likely(!req->req.no_interrupt || !use_dma_chaining))
net2280.c:719:	/* td->dmadesc = previously set by caller */
net2280.c:720:	td->dmaaddr = cpu_to_le32 (req->req.dma);
net2280.c:722:	/* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
net2280.c:724:	td->dmacount = cpu_to_le32p (&dmacount);
net2280.c:740:	handshake (&dma->dmactl, (1 << DMA_ENABLE), 0, 50);
net2280.c:745:	writel (readl (&dma->dmactl) & ~(1 << DMA_ENABLE), &dma->dmactl);
net2280.c:751:	struct net2280_dma_regs	__iomem *dma = ep->dma;
net2280.c:753:	writel ((1 << VALID_BIT) | (ep->is_in << DMA_DIRECTION),
net2280.c:754:			&dma->dmacount);
net2280.c:755:	writel (readl (&dma->dmastat), &dma->dmastat);
net2280.c:757:	writel (td_dma, &dma->dmadesc);
net2280.c:758:	writel (dmactl, &dma->dmactl);
net2280.c:761:	(void) readl (&ep->dev->pci->pcimstctl);
net2280.c:763:	writel ((1 << DMA_START), &dma->dmastat);
net2280.c:765:	if (!ep->is_in)
net2280.c:772:	struct net2280_dma_regs	__iomem *dma = ep->dma;
net2280.c:777:	WARN_ON (readl (&dma->dmactl) & (1 << DMA_ENABLE));
net2280.c:778:	writel (0, &ep->dma->dmactl);
net2280.c:781:	if (!ep->is_in && ((tmp = readl (&ep->regs->ep_stat))
net2280.c:784:			&ep->regs->ep_stat);
net2280.c:786:		tmp = readl (&ep->regs->ep_avail);
net2280.c:788:			writel (readl (&dma->dmastat), &dma->dmastat);
net2280.c:791:			writel (req->req.dma, &dma->dmaaddr);
net2280.c:792:			tmp = min (tmp, req->req.length);
net2280.c:795:			req->td->dmacount = cpu_to_le32 (req->req.length - tmp);
net2280.c:797:				| tmp, &dma->dmacount);
net2280.c:798:			req->td->dmadesc = 0;
net2280.c:799:			req->valid = 1;
net2280.c:801:			writel ((1 << DMA_ENABLE), &dma->dmactl);
net2280.c:802:			writel ((1 << DMA_START), &dma->dmastat);
net2280.c:813:	if (ep->is_in) {
net2280.c:814:		if (likely ((req->req.length % ep->ep.maxpacket) != 0
net2280.c:815:				|| req->req.zero)) {
net2280.c:817:			ep->in_fifo_validate = 1;
net2280.c:819:			ep->in_fifo_validate = 0;
net2280.c:822:	/* init req->td, pointing to the current dummy */
net2280.c:823:	req->td->dmadesc = cpu_to_le32 (ep->td_dma);
net2280.c:827:		req->td->dmacount |= __constant_cpu_to_le32 (1 << END_OF_CHAIN);
net2280.c:829:	start_queue (ep, tmp, req->td_dma);
net2280.c:839:	end = ep->dummy;
net2280.c:840:	ep->dummy = req->td;
net2280.c:841:	req->td = end;
net2280.c:843:	tmp = ep->td_dma;
net2280.c:844:	ep->td_dma = req->td_dma;
net2280.c:845:	req->td_dma = tmp;
net2280.c:847:	end->dmadesc = cpu_to_le32 (ep->td_dma);
net2280.c:856:	unsigned		stopped = ep->stopped;
net2280.c:858:	list_del_init (&req->queue);
net2280.c:860:	if (req->req.status == -EINPROGRESS)
net2280.c:861:		req->req.status = status;
net2280.c:863:		status = req->req.status;
net2280.c:865:	dev = ep->dev;
net2280.c:866:	if (req->mapped) {
net2280.c:867:		pci_unmap_single (dev->pdev, req->req.dma, req->req.length,
net2280.c:868:			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
net2280.c:869:		req->req.dma = DMA_ADDR_INVALID;
net2280.c:870:		req->mapped = 0;
net2280.c:873:	if (status && status != -ESHUTDOWN)
net2280.c:875:			ep->ep.name, &req->req, status,
net2280.c:876:			req->req.actual, req->req.length);
net2280.c:879:	ep->stopped = 1;
net2280.c:880:	spin_unlock (&dev->lock);
net2280.c:881:	req->req.complete (&ep->ep, &req->req);
net2280.c:882:	spin_lock (&dev->lock);
net2280.c:883:	ep->stopped = stopped;
net2280.c:886:/*-------------------------------------------------------------------------*/
net2280.c:896:	/* we always require a cpu-view buffer, so that we can
net2280.c:900:	if (!_req || !_req->complete || !_req->buf
net2280.c:901:			|| !list_empty (&req->queue))
net2280.c:902:		return -EINVAL;
net2280.c:903:	if (_req->length > (~0 & DMA_BYTE_COUNT_MASK))
net2280.c:904:		return -EDOM;
net2280.c:906:	if (!_ep || (!ep->desc && ep->num != 0))
net2280.c:907:		return -EINVAL;
net2280.c:908:	dev = ep->dev;
net2280.c:909:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:910:		return -ESHUTDOWN;
net2280.c:913:	if (ep->dma && _req->length == 0)
net2280.c:914:		return -EOPNOTSUPP;
net2280.c:917:	if (ep->dma && _req->dma == DMA_ADDR_INVALID) {
net2280.c:918:		_req->dma = pci_map_single (dev->pdev, _req->buf, _req->length,
net2280.c:919:			ep->is_in ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
net2280.c:920:		req->mapped = 1;
net2280.c:925:			_ep->name, _req, _req->length, _req->buf);
net2280.c:928:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:930:	_req->status = -EINPROGRESS;
net2280.c:931:	_req->actual = 0;
net2280.c:934:	if (list_empty (&ep->queue) && !ep->stopped) {
net2280.c:936:		if (ep->dma)
net2280.c:940:			if (ep->num == 0 && _req->length == 0) {
net2280.c:943:				VDEBUG (dev, "%s status ack\n", ep->ep.name);
net2280.c:948:			if (ep->is_in)
net2280.c:950:			else if (list_empty (&ep->queue)) {
net2280.c:954:				s = readl (&ep->regs->ep_stat);
net2280.c:956:					/* note:  _req->short_not_ok is
net2280.c:959:					 * _req->status doesn't change for
net2280.c:960:					 * short reads (only _req->actual)
net2280.c:964:						if (ep->num == 0)
net2280.c:969:						s = readl (&ep->regs->ep_stat);
net2280.c:975:							&ep->regs->ep_rsp);
net2280.c:979:	} else if (ep->dma) {
net2280.c:982:		if (ep->is_in) {
net2280.c:985:			/* preventing magic zlps is per-engine state, not
net2280.c:986:			 * per-transfer; irq logic must recover hiccups.
net2280.c:988:			expect = likely (req->req.zero
net2280.c:989:				|| (req->req.length % ep->ep.maxpacket) != 0);
net2280.c:990:			if (expect != ep->in_fifo_validate)
net2280.c:998:		list_add_tail (&req->queue, &ep->queue);
net2280.c:1000:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1014:	req->req.actual = req->req.length - (DMA_BYTE_COUNT_MASK & dmacount);
net2280.c:1025:	while (!list_empty (&ep->queue)) {
net2280.c:1029:		req = list_entry (ep->queue.next,
net2280.c:1031:		if (!req->valid)
net2280.c:1034:		tmp = le32_to_cpup (&req->td->dmacount);
net2280.c:1038:		/* SHORT_PACKET_TRANSFERRED_INTERRUPT handles "usb-short"
net2280.c:1040:		 * all non-abort DMA completions.
net2280.c:1042:		if (unlikely (req->td->dmadesc == 0)) {
net2280.c:1044:			tmp = readl (&ep->dma->dmacount);
net2280.c:1050:		} else if (!ep->is_in
net2280.c:1051:				&& (req->req.length % ep->ep.maxpacket) != 0) {
net2280.c:1052:			tmp = readl (&ep->regs->ep_stat);
net2280.c:1059:				WARN (ep->dev, "%s lost packet sync!\n",
net2280.c:1060:						ep->ep.name);
net2280.c:1061:				req->req.status = -EOVERFLOW;
net2280.c:1062:			} else if ((tmp = readl (&ep->regs->ep_avail)) != 0) {
net2280.c:1064:				ep->out_overflow = 1;
net2280.c:1065:				DEBUG (ep->dev, "%s dma, discard %d len %d\n",
net2280.c:1066:						ep->ep.name, tmp,
net2280.c:1067:						req->req.length);
net2280.c:1068:				req->req.status = -EOVERFLOW;
net2280.c:1080:	if (ep->stopped)
net2280.c:1082:	req = list_entry (ep->queue.next, struct net2280_request, queue);
net2280.c:1093:	 *  OUT:  was "usb-short", we must restart.
net2280.c:1095:	if (ep->is_in && !req->valid) {
net2280.c:1099:		DEBUG (ep->dev, "%s dma hiccup td %p\n", ep->ep.name, req->td);
net2280.c:1100:		ep->in_fifo_validate = likely (req->req.zero
net2280.c:1101:			|| (req->req.length % ep->ep.maxpacket) != 0);
net2280.c:1102:		if (ep->in_fifo_validate)
net2280.c:1104:		list_for_each_entry (entry, &ep->queue, queue) {
net2280.c:1109:			dmacount = entry->td->dmacount;
net2280.c:1111:				reqmode = likely (entry->req.zero
net2280.c:1112:					|| (entry->req.length
net2280.c:1113:						% ep->ep.maxpacket) != 0);
net2280.c:1114:				if (reqmode == ep->in_fifo_validate) {
net2280.c:1115:					entry->valid = 1;
net2280.c:1117:					entry->td->dmacount = dmacount;
net2280.c:1122:					prev->td->dmacount |= dma_done_ie;
net2280.c:1128:			entry->valid = 0;
net2280.c:1130:			entry->td->dmacount = dmacount;
net2280.c:1135:	writel (0, &ep->dma->dmactl);
net2280.c:1136:	start_queue (ep, dmactl, req->td_dma);
net2280.c:1142:	if (likely (!list_empty (&ep->queue))) {
net2280.c:1144:		writel ((1 << DMA_ABORT), &ep->dma->dmastat);
net2280.c:1145:		spin_stop_dma (ep->dma);
net2280.c:1147:		stop_dma (ep->dma);
net2280.c:1157:	ep->stopped = 1;
net2280.c:1158:	if (ep->dma)
net2280.c:1160:	while (!list_empty (&ep->queue)) {
net2280.c:1161:		req = list_entry (ep->queue.next,
net2280.c:1164:		done (ep, req, -ESHUTDOWN);
net2280.c:1178:	if (!_ep || (!ep->desc && ep->num != 0) || !_req)
net2280.c:1179:		return -EINVAL;
net2280.c:1181:	spin_lock_irqsave (&ep->dev->lock, flags);
net2280.c:1182:	stopped = ep->stopped;
net2280.c:1186:	ep->stopped = 1;
net2280.c:1187:	if (ep->dma) {
net2280.c:1188:		dmactl = readl (&ep->dma->dmactl);
net2280.c:1190:		stop_dma (ep->dma);
net2280.c:1195:	list_for_each_entry (req, &ep->queue, queue) {
net2280.c:1196:		if (&req->req == _req)
net2280.c:1199:	if (&req->req != _req) {
net2280.c:1200:		spin_unlock_irqrestore (&ep->dev->lock, flags);
net2280.c:1201:		return -EINVAL;
net2280.c:1205:	if (ep->queue.next == &req->queue) {
net2280.c:1206:		if (ep->dma) {
net2280.c:1207:			DEBUG (ep->dev, "unlink (%s) dma\n", _ep->name);
net2280.c:1208:			_req->status = -ECONNRESET;
net2280.c:1210:			if (likely (ep->queue.next == &req->queue)) {
net2280.c:1211:				// NOTE: misreports single-transfer mode
net2280.c:1212:				req->td->dmacount = 0;	/* invalidate */
net2280.c:1214:					readl (&ep->dma->dmacount),
net2280.c:1215:					-ECONNRESET);
net2280.c:1218:			DEBUG (ep->dev, "unlink (%s) pio\n", _ep->name);
net2280.c:1219:			done (ep, req, -ECONNRESET);
net2280.c:1224:	} else if (ep->dma && use_dma_chaining) {
net2280.c:1225:		if (req->queue.prev == ep->queue.next) {
net2280.c:1226:			writel (le32_to_cpu (req->td->dmadesc),
net2280.c:1227:				&ep->dma->dmadesc);
net2280.c:1228:			if (req->td->dmacount & dma_done_ie)
net2280.c:1229:				writel (readl (&ep->dma->dmacount)
net2280.c:1231:					&ep->dma->dmacount);
net2280.c:1235:			prev = list_entry (req->queue.prev,
net2280.c:1237:			prev->td->dmadesc = req->td->dmadesc;
net2280.c:1238:			if (req->td->dmacount & dma_done_ie)
net2280.c:1239:				prev->td->dmacount |= dma_done_ie;
net2280.c:1244:		done (ep, req, -ECONNRESET);
net2280.c:1245:	ep->stopped = stopped;
net2280.c:1247:	if (ep->dma) {
net2280.c:1249:		if (list_empty (&ep->queue))
net2280.c:1250:			stop_dma (ep->dma);
net2280.c:1251:		else if (!ep->stopped) {
net2280.c:1254:				writel (dmactl, &ep->dma->dmactl);
net2280.c:1256:				start_dma (ep, list_entry (ep->queue.next,
net2280.c:1261:	spin_unlock_irqrestore (&ep->dev->lock, flags);
net2280.c:1262:	return req ? 0 : -EOPNOTSUPP;
net2280.c:1265:/*-------------------------------------------------------------------------*/
net2280.c:1277:	if (!_ep || (!ep->desc && ep->num != 0))
net2280.c:1278:		return -EINVAL;
net2280.c:1279:	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:1280:		return -ESHUTDOWN;
net2280.c:1281:	if (ep->desc /* not ep0 */ && (ep->desc->bmAttributes & 0x03)
net2280.c:1283:		return -EINVAL;
net2280.c:1285:	spin_lock_irqsave (&ep->dev->lock, flags);
net2280.c:1286:	if (!list_empty (&ep->queue))
net2280.c:1287:		retval = -EAGAIN;
net2280.c:1288:	else if (ep->is_in && value && net2280_fifo_status (_ep) != 0)
net2280.c:1289:		retval = -EAGAIN;
net2280.c:1291:		VDEBUG (ep->dev, "%s %s halt\n", _ep->name,
net2280.c:1295:			if (ep->num == 0)
net2280.c:1296:				ep->dev->protocol_stall = 1;
net2280.c:1301:		(void) readl (&ep->regs->ep_rsp);
net2280.c:1303:	spin_unlock_irqrestore (&ep->dev->lock, flags);
net2280.c:1315:	if (!_ep || (!ep->desc && ep->num != 0))
net2280.c:1316:		return -ENODEV;
net2280.c:1317:	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:1318:		return -ESHUTDOWN;
net2280.c:1320:	avail = readl (&ep->regs->ep_avail) & ((1 << 12) - 1);
net2280.c:1321:	if (avail > ep->fifo_size)
net2280.c:1322:		return -EOVERFLOW;
net2280.c:1323:	if (ep->is_in)
net2280.c:1324:		avail = ep->fifo_size - avail;
net2280.c:1334:	if (!_ep || (!ep->desc && ep->num != 0))
net2280.c:1336:	if (!ep->dev->driver || ep->dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:1339:	writel ((1 << FIFO_FLUSH), &ep->regs->ep_stat);
net2280.c:1340:	(void) readl (&ep->regs->ep_rsp);
net2280.c:1361:/*-------------------------------------------------------------------------*/
net2280.c:1370:		return -ENODEV;
net2280.c:1372:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1373:	retval = get_idx_reg (dev->regs, REG_FRAME) & 0x03ff;
net2280.c:1374:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1388:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1389:	tmp = readl (&dev->usb->usbctl);
net2280.c:1391:		writel (1 << GENERATE_RESUME, &dev->usb->usbstat);
net2280.c:1392:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1408:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1409:	tmp = readl (&dev->usb->usbctl);
net2280.c:1414:	writel (tmp, &dev->usb->usbctl);
net2280.c:1415:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1427:		return -ENODEV;
net2280.c:1430:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1431:	tmp = readl (&dev->usb->usbctl);
net2280.c:1432:	dev->softconnect = (is_on != 0);
net2280.c:1437:	writel (tmp, &dev->usb->usbctl);
net2280.c:1438:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1450:/*-------------------------------------------------------------------------*/
net2280.c:1465:	if (!dev->driver
net2280.c:1466:			|| !dev->driver->function
net2280.c:1467:			|| strlen (dev->driver->function) > PAGE_SIZE)
net2280.c:1469:	return scnprintf (buf, PAGE_SIZE, "%s\n", dev->driver->function);
net2280.c:1487:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1489:	if (dev->driver)
net2280.c:1490:		s = dev->driver->driver.name;
net2280.c:1500:			driver_name, dev->chiprev,
net2280.c:1504:			readl (&dev->regs->devinit),
net2280.c:1505:			readl (&dev->regs->fifoctl),
net2280.c:1507:			readl (&dev->regs->pciirqenb0),
net2280.c:1508:			readl (&dev->regs->pciirqenb1),
net2280.c:1509:			readl (&dev->regs->irqstat0),
net2280.c:1510:			readl (&dev->regs->irqstat1));
net2280.c:1511:	size -= t;
net2280.c:1515:	t1 = readl (&dev->usb->usbctl);
net2280.c:1516:	t2 = readl (&dev->usb->usbstat);
net2280.c:1520:		else if (dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:1530:			readl (&dev->usb->stdrsp), t1, t2,
net2280.c:1531:			readl (&dev->usb->ouraddr), s);
net2280.c:1532:	size -= t;
net2280.c:1543:		ep = &dev->ep [i];
net2280.c:1544:		if (i && !ep->desc)
net2280.c:1547:		t1 = readl (&ep->regs->ep_cfg);
net2280.c:1548:		t2 = readl (&ep->regs->ep_rsp) & 0xff;
net2280.c:1552:				ep->ep.name, t1, t2,
net2280.c:1569:				readl (&ep->regs->ep_irqenb));
net2280.c:1570:		size -= t;
net2280.c:1575:				"(ep%d%s-%s)%s\n",
net2280.c:1576:				readl (&ep->regs->ep_stat),
net2280.c:1577:				readl (&ep->regs->ep_avail),
net2280.c:1580:				ep->stopped ? "*" : "");
net2280.c:1581:		size -= t;
net2280.c:1584:		if (!ep->dma)
net2280.c:1590:				readl (&ep->dma->dmactl),
net2280.c:1591:				readl (&ep->dma->dmastat),
net2280.c:1592:				readl (&ep->dma->dmacount),
net2280.c:1593:				readl (&ep->dma->dmaaddr),
net2280.c:1594:				readl (&ep->dma->dmadesc));
net2280.c:1595:		size -= t;
net2280.c:1605:	size -= t;
net2280.c:1610:		ep = &dev->ep [i];
net2280.c:1611:		if (i && !ep->irqs)
net2280.c:1613:		t = scnprintf (next, size, " %s/%lu", ep->ep.name, ep->irqs);
net2280.c:1614:		size -= t;
net2280.c:1619:	size -= t;
net2280.c:1622:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1624:	return PAGE_SIZE - size;
net2280.c:1640:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1643:		struct net2280_ep		*ep = &dev->ep [i];
net2280.c:1650:			d = ep->desc;
net2280.c:1653:			t = d->bEndpointAddress;
net2280.c:1655:				"\n%s (ep%d%s-%s) max %04x %s fifo %d\n",
net2280.c:1656:				ep->ep.name, t & USB_ENDPOINT_NUMBER_MASK,
net2280.c:1659:				 switch (d->bmAttributes & 0x03) {
net2280.c:1667:				le16_to_cpu (d->wMaxPacketSize) & 0x1fff,
net2280.c:1668:				ep->dma ? "dma" : "pio", ep->fifo_size
net2280.c:1672:					ep->is_in ? "in" : "out");
net2280.c:1675:		size -= t;
net2280.c:1678:		if (list_empty (&ep->queue)) {
net2280.c:1682:			size -= t;
net2280.c:1686:		list_for_each_entry (req, &ep->queue, queue) {
net2280.c:1687:			if (ep->dma && req->td_dma == readl (&ep->dma->dmadesc))
net2280.c:1691:					&req->req, req->req.actual,
net2280.c:1692:					req->req.length, req->req.buf,
net2280.c:1693:					readl (&ep->dma->dmacount));
net2280.c:1697:					&req->req, req->req.actual,
net2280.c:1698:					req->req.length, req->req.buf);
net2280.c:1701:			size -= t;
net2280.c:1704:			if (ep->dma) {
net2280.c:1707:				td = req->td;
net2280.c:1710:					(u32) req->td_dma,
net2280.c:1711:					le32_to_cpu (td->dmacount),
net2280.c:1712:					le32_to_cpu (td->dmaaddr),
net2280.c:1713:					le32_to_cpu (td->dmadesc));
net2280.c:1716:				size -= t;
net2280.c:1723:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1724:	return PAGE_SIZE - size;
net2280.c:1736:/*-------------------------------------------------------------------------*/
net2280.c:1738:/* another driver-specific mode might be a request type doing dma
net2280.c:1745:	writel ((0xffff << PCI_BASE2_RANGE) | mode, &dev->regs->fifoctl);
net2280.c:1747:	/* always ep-{a,b,e,f} ... maybe not ep-c or ep-d */
net2280.c:1748:	INIT_LIST_HEAD (&dev->gadget.ep_list);
net2280.c:1749:	list_add_tail (&dev->ep [1].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1750:	list_add_tail (&dev->ep [2].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1753:		list_add_tail (&dev->ep [3].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1754:		list_add_tail (&dev->ep [4].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1755:		dev->ep [1].fifo_size = dev->ep [2].fifo_size = 1024;
net2280.c:1758:		dev->ep [1].fifo_size = dev->ep [2].fifo_size = 2048;
net2280.c:1761:		list_add_tail (&dev->ep [3].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1762:		dev->ep [1].fifo_size = 2048;
net2280.c:1763:		dev->ep [2].fifo_size = 1024;
net2280.c:1766:	/* fifo sizes for ep0, ep-c, ep-d, ep-e, and ep-f never change */
net2280.c:1767:	list_add_tail (&dev->ep [5].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1768:	list_add_tail (&dev->ep [6].ep.ep_list, &dev->gadget.ep_list);
net2280.c:1772: * net2280_set_fifo_mode - change allocation of fifo buffers
net2280.c:1774: * @mode: 0 for default, four 1kB buffers (ep-a through ep-d);
net2280.c:1775: * 	1 for two 2kB buffers (ep-a and ep-b only);
net2280.c:1776: * 	2 for one 2kB buffer (ep-a) and two 1kB ones (ep-b, ep-c).
net2280.c:1779: * the contents of gadget->ep_list may have changed.
net2280.c:1781: * you may only call this function when endpoints a-d are all disabled.
net2280.c:1795:		return -ENODEV;
net2280.c:1798:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:1801:		if (dev->ep [i].desc) {
net2280.c:1802:			status = -EINVAL;
net2280.c:1806:		status = -EINVAL;
net2280.c:1809:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:1813:			DEBUG (dev, "fifo:  ep-a 2K, ep-b 2K\n");
net2280.c:1815:			DEBUG (dev, "fifo:  ep-a 2K, ep-b 1K, ep-c 1K\n");
net2280.c:1822:/*-------------------------------------------------------------------------*/
net2280.c:1825: * - one bus driver, initted first;
net2280.c:1826: * - one function driver, initted second
net2280.c:1839:	dev->gadget.speed = USB_SPEED_UNKNOWN;
net2280.c:1840:	(void) readl (&dev->usb->usbctl);
net2280.c:1845:	writel (0, &dev->usb->stdrsp);
net2280.c:1846:	writel (0, &dev->regs->pciirqenb0);
net2280.c:1847:	writel (0, &dev->regs->pciirqenb1);
net2280.c:1851:		struct net2280_ep	*ep = &dev->ep [tmp + 1];
net2280.c:1853:		if (ep->dma)
net2280.c:1856:	writel (~0, &dev->regs->irqstat0),
net2280.c:1857:	writel (~(1 << SUSPEND_REQUEST_INTERRUPT), &dev->regs->irqstat1),
net2280.c:1860:	tmp = readl (&dev->regs->devinit)
net2280.c:1865:	writel (tmp, &dev->regs->devinit);
net2280.c:1876:	/* use_dma changes are ignored till next device re-init */
net2280.c:1881:		struct net2280_ep	*ep = &dev->ep [tmp];
net2280.c:1883:		ep->ep.name = ep_name [tmp];
net2280.c:1884:		ep->dev = dev;
net2280.c:1885:		ep->num = tmp;
net2280.c:1888:			ep->fifo_size = 1024;
net2280.c:1890:				ep->dma = &dev->dma [tmp - 1];
net2280.c:1892:			ep->fifo_size = 64;
net2280.c:1893:		ep->regs = &dev->epregs [tmp];
net2280.c:1894:		ep_reset (dev->regs, ep);
net2280.c:1896:	dev->ep [0].ep.maxpacket = 64;
net2280.c:1897:	dev->ep [5].ep.maxpacket = 64;
net2280.c:1898:	dev->ep [6].ep.maxpacket = 64;
net2280.c:1900:	dev->gadget.ep0 = &dev->ep [0].ep;
net2280.c:1901:	dev->ep [0].stopped = 0;
net2280.c:1902:	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
net2280.c:1908:		writel (EP_DONTUSE, &dev->dep [tmp].dep_cfg);
net2280.c:1916:		, &dev->epregs [0].ep_rsp);
net2280.c:1929:		, &dev->usb->stdrsp);
net2280.c:1933:		| (dev->softconnect << USB_DETECT_ENABLE)
net2280.c:1935:		, &dev->usb->usbctl);
net2280.c:1940:		, &dev->regs->pciirqenb0);
net2280.c:1948:		, &dev->regs->pciirqenb1);
net2280.c:1951:	(void) readl (&dev->usb->usbctl);
net2280.c:1956: * non-control requests.  then usb traffic follows until a
net2280.c:1967:	 * (dev->usb->xcvrdiag & FORCE_FULL_SPEED_MODE)
net2280.c:1971:			|| driver->speed != USB_SPEED_HIGH
net2280.c:1972:			|| !driver->bind
net2280.c:1973:			|| !driver->unbind
net2280.c:1974:			|| !driver->setup)
net2280.c:1975:		return -EINVAL;
net2280.c:1977:		return -ENODEV;
net2280.c:1978:	if (dev->driver)
net2280.c:1979:		return -EBUSY;
net2280.c:1982:		dev->ep [i].irqs = 0;
net2280.c:1985:	dev->softconnect = 1;
net2280.c:1986:	driver->driver.bus = NULL;
net2280.c:1987:	dev->driver = driver;
net2280.c:1988:	dev->gadget.dev.driver = &driver->driver;
net2280.c:1989:	retval = driver->bind (&dev->gadget);
net2280.c:1991:		DEBUG (dev, "bind to driver %s --> %d\n",
net2280.c:1992:				driver->driver.name, retval);
net2280.c:1993:		dev->driver = NULL;
net2280.c:1994:		dev->gadget.dev.driver = NULL;
net2280.c:1998:	device_create_file (&dev->pdev->dev, &dev_attr_function);
net2280.c:1999:	device_create_file (&dev->pdev->dev, &dev_attr_queues);
net2280.c:2008:			driver->driver.name,
net2280.c:2009:			readl (&dev->usb->usbctl),
net2280.c:2010:			readl (&dev->usb->stdrsp));
net2280.c:2023:	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
net2280.c:2031:		nuke (&dev->ep [i]);
net2280.c:2035:		spin_unlock (&dev->lock);
net2280.c:2036:		driver->disconnect (&dev->gadget);
net2280.c:2037:		spin_lock (&dev->lock);
net2280.c:2049:		return -ENODEV;
net2280.c:2050:	if (!driver || driver != dev->driver)
net2280.c:2051:		return -EINVAL;
net2280.c:2053:	spin_lock_irqsave (&dev->lock, flags);
net2280.c:2055:	spin_unlock_irqrestore (&dev->lock, flags);
net2280.c:2057:	net2280_pullup (&dev->gadget, 0);
net2280.c:2059:	driver->unbind (&dev->gadget);
net2280.c:2060:	dev->gadget.dev.driver = NULL;
net2280.c:2061:	dev->driver = NULL;
net2280.c:2064:	device_remove_file (&dev->pdev->dev, &dev_attr_function);
net2280.c:2065:	device_remove_file (&dev->pdev->dev, &dev_attr_queues);
net2280.c:2067:	DEBUG (dev, "unregistered driver '%s'\n", driver->driver.name);
net2280.c:2073:/*-------------------------------------------------------------------------*/
net2280.c:2075:/* handle ep0, ep-e, ep-f with 64 byte packets: packet per irq.
net2280.c:2076: * also works for dma-capable endpoints, in pio mode or just
net2280.c:2083:	/* 0 error, 1 mid-data, 2 done */
net2280.c:2086:	if (!list_empty (&ep->queue))
net2280.c:2087:		req = list_entry (ep->queue.next,
net2280.c:2093:	t = readl (&ep->regs->ep_stat);
net2280.c:2094:	ep->irqs++;
net2280.c:2096:	VDEBUG (ep->dev, "%s ack ep_stat %08x, req %p\n",
net2280.c:2097:			ep->ep.name, t, req ? &req->req : 0);
net2280.c:2099:	writel (t & ~(1 << NAK_OUT_PACKETS), &ep->regs->ep_stat);
net2280.c:2111:	if (unlikely (ep->num == 0)) {
net2280.c:2112:		if (ep->is_in) {
net2280.c:2115:				if (ep->dev->protocol_stall) {
net2280.c:2116:					ep->stopped = 1;
net2280.c:2124:				if (ep->dev->protocol_stall) {
net2280.c:2125:					ep->stopped = 1;
net2280.c:2128:				} else if (!req && ep->stopped)
net2280.c:2134:				if (ep->dev->protocol_stall) {
net2280.c:2135:					ep->stopped = 1;
net2280.c:2142:					&& req->req.actual == req->req.length)
net2280.c:2144:				ep->dev->protocol_stall = 1;
net2280.c:2146:				ep->stopped = 1;
net2280.c:2148:					done (ep, req, -EOVERFLOW);
net2280.c:2158:	if (likely (ep->dma != 0)) {
net2280.c:2161:			int	stopped = ep->stopped;
net2280.c:2167:			ep->stopped = 1;
net2280.c:2168:			for (count = 0; ; t = readl (&ep->regs->ep_stat)) {
net2280.c:2174:				if (unlikely (list_empty (&ep->queue)
net2280.c:2175:						|| ep->out_overflow)) {
net2280.c:2179:				req = list_entry (ep->queue.next,
net2280.c:2186:					count = readl (&ep->dma->dmacount);
net2280.c:2188:					if (readl (&ep->dma->dmadesc)
net2280.c:2189:							!= req->td_dma)
net2280.c:2197:			writel ((1 << DMA_ABORT), &ep->dma->dmastat);
net2280.c:2198:			spin_stop_dma (ep->dma);
net2280.c:2201:				req->td->dmacount = 0;
net2280.c:2202:				t = readl (&ep->regs->ep_avail);
net2280.c:2207:			if (unlikely (ep->out_overflow
net2280.c:2208:					|| (ep->dev->chiprev == 0x0100
net2280.c:2209:						&& ep->dev->gadget.speed
net2280.c:2212:				ep->out_overflow = 0;
net2280.c:2216:			ep->stopped = stopped;
net2280.c:2217:			if (!list_empty (&ep->queue))
net2280.c:2220:			DEBUG (ep->dev, "%s dma ep_stat %08x ??\n",
net2280.c:2221:					ep->ep.name, t);
net2280.c:2226:		if (read_fifo (ep, req) && ep->num != 0)
net2280.c:2233:		len = req->req.length - req->req.actual;
net2280.c:2234:		if (len > ep->ep.maxpacket)
net2280.c:2235:			len = ep->ep.maxpacket;
net2280.c:2236:		req->req.actual += len;
net2280.c:2239:		if (req->req.actual == req->req.length) {
net2280.c:2240:			if (ep->num == 0) {
net2280.c:2244:			} else if (!req->req.zero || len != ep->ep.maxpacket)
net2280.c:2258:		if (ep->num == 0) {
net2280.c:2263:			if (!ep->stopped)
net2280.c:2267:			if (!list_empty (&ep->queue) && !ep->stopped)
net2280.c:2268:				req = list_entry (ep->queue.next,
net2280.c:2272:			if (req && !ep->is_in)
net2280.c:2280:	if (req && !ep->stopped) {
net2280.c:2284:			write_fifo (ep, &req->req);
net2280.c:2294:		return &dev->ep [0];
net2280.c:2295:	list_for_each_entry (ep, &dev->gadget.ep_list, ep.ep_list) {
net2280.c:2298:		if (!ep->desc)
net2280.c:2300:		bEndpointAddress = ep->desc->bEndpointAddress;
net2280.c:2329:		if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
net2280.c:2330:			if (readl (&dev->usb->usbstat) & (1 << HIGH_SPEED))
net2280.c:2331:				dev->gadget.speed = USB_SPEED_HIGH;
net2280.c:2333:				dev->gadget.speed = USB_SPEED_FULL;
net2280.c:2334:			net2280_led_speed (dev, dev->gadget.speed);
net2280.c:2336:				(dev->gadget.speed == USB_SPEED_HIGH)
net2280.c:2340:		ep = &dev->ep [0];
net2280.c:2341:		ep->irqs++;
net2280.c:2345:		while (!list_empty (&ep->queue)) {
net2280.c:2346:			req = list_entry (ep->queue.next,
net2280.c:2348:			done (ep, req, (req->req.actual == req->req.length)
net2280.c:2349:						? 0 : -EPROTO);
net2280.c:2351:		ep->stopped = 0;
net2280.c:2352:		dev->protocol_stall = 0;
net2280.c:2367:			, &ep->regs->ep_stat);
net2280.c:2368:		u.raw [0] = readl (&dev->usb->setup0123);
net2280.c:2369:		u.raw [1] = readl (&dev->usb->setup4567);
net2280.c:2379:		writel (1 << SETUP_PACKET_INTERRUPT, &dev->regs->irqstat0);
net2280.c:2387:		ep->is_in = (u.r.bRequestType & USB_DIR_IN) != 0;
net2280.c:2388:		if (ep->is_in) {
net2280.c:2397:		writel (scratch, &dev->epregs [0].ep_irqenb);
net2280.c:2414:			if (readl (&e->regs->ep_rsp)
net2280.c:2421:			writel (0, &dev->epregs [0].ep_irqenb);
net2280.c:2423:			writel (status, &dev->epregs [0].ep_data);
net2280.c:2425:			VDEBUG (dev, "%s stat %02x\n", ep->ep.name, status);
net2280.c:2442:			VDEBUG (dev, "%s clear halt\n", ep->ep.name);
net2280.c:2459:			VDEBUG (dev, "%s set halt\n", ep->ep.name);
net2280.c:2469:				readl (&ep->regs->ep_cfg));
net2280.c:2470:			spin_unlock (&dev->lock);
net2280.c:2471:			tmp = dev->driver->setup (&dev->gadget, &u.r);
net2280.c:2472:			spin_lock (&dev->lock);
net2280.c:2480:			dev->protocol_stall = 1;
net2280.c:2502:		ep = &dev->ep [num];
net2280.c:2535:		writel (tmp, &dev->regs->irqstat1);
net2280.c:2537:				((readl (&dev->usb->usbstat) & mask) == 0))
net2280.c:2538:				|| ((readl (&dev->usb->usbctl) & (1 << VBUS_PIN)) == 0) 
net2280.c:2539:			    ) && ( dev->gadget.speed != USB_SPEED_UNKNOWN)) {
net2280.c:2541:					dev->driver->driver.name);
net2280.c:2542:			stop_activity (dev, dev->driver);
net2280.c:2560:		writel (tmp, &dev->regs->irqstat1);
net2280.c:2562:			if (dev->driver->suspend)
net2280.c:2563:				dev->driver->suspend (&dev->gadget);
net2280.c:2565:			if (dev->driver->resume)
net2280.c:2566:				dev->driver->resume (&dev->gadget);
net2280.c:2574:		writel (stat, &dev->regs->irqstat1);
net2280.c:2585:	/* DMA status, for ep-{a,b,c,d} */
net2280.c:2597:		ep = &dev->ep [num + 1];
net2280.c:2598:		dma = ep->dma;
net2280.c:2604:		tmp = readl (&dma->dmastat);
net2280.c:2605:		writel (tmp, &dma->dmastat);
net2280.c:2613:				DEBUG (ep->dev, "%s no xact done? %08x\n",
net2280.c:2614:					ep->ep.name, tmp);
net2280.c:2617:			stop_dma (ep->dma);
net2280.c:2623:		 * less than req->length. NAK_OUT_PACKETS may be set,
net2280.c:2628:		 * precisely (like PIO does) needs per-packet irqs
net2280.c:2633:		if (list_empty (&ep->queue)) {
net2280.c:2635:				stop_dma (ep->dma);
net2280.c:2637:			tmp = readl (&dma->dmactl);
net2280.c:2641:			else if (ep->is_in && use_dma_chaining) {
net2280.c:2650:				req = list_entry (ep->queue.next,
net2280.c:2652:				dmacount = req->td->dmacount;
net2280.c:2660:		ep->irqs++;
net2280.c:2672:		stop_activity (dev, dev->driver);
net2280.c:2685:	spin_lock (&dev->lock);
net2280.c:2688:	handle_stat1_irqs (dev, readl (&dev->regs->irqstat1));
net2280.c:2691:	handle_stat0_irqs (dev, readl (&dev->regs->irqstat0));
net2280.c:2693:	spin_unlock (&dev->lock);
net2280.c:2698:/*-------------------------------------------------------------------------*/
net2280.c:2714:	if (dev->driver) {
net2280.c:2717:				dev->driver->driver.name);
net2280.c:2718:		usb_gadget_unregister_driver (dev->driver);
net2280.c:2723:	if (dev->requests) {
net2280.c:2726:			if (!dev->ep [i].dummy)
net2280.c:2728:			pci_pool_free (dev->requests, dev->ep [i].dummy,
net2280.c:2729:					dev->ep [i].td_dma);
net2280.c:2731:		pci_pool_destroy (dev->requests);
net2280.c:2733:	if (dev->got_irq)
net2280.c:2734:		free_irq (pdev->irq, dev);
net2280.c:2735:	if (dev->regs)
net2280.c:2736:		iounmap (dev->regs);
net2280.c:2737:	if (dev->region)
net2280.c:2740:	if (dev->enabled)
net2280.c:2742:	device_unregister (&dev->gadget.dev);
net2280.c:2743:	device_remove_file (&pdev->dev, &dev_attr_registers);
net2280.c:2767:		dev_warn (&pdev->dev, "ignoring\n");
net2280.c:2768:		return -EBUSY;
net2280.c:2774:		retval = -ENOMEM;
net2280.c:2779:	spin_lock_init (&dev->lock);
net2280.c:2780:	dev->pdev = pdev;
net2280.c:2781:	dev->gadget.ops = &net2280_ops;
net2280.c:2782:	dev->gadget.is_dualspeed = 1;
net2280.c:2785:	strcpy (dev->gadget.dev.bus_id, "gadget");
net2280.c:2786:	dev->gadget.dev.parent = &pdev->dev;
net2280.c:2787:	dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
net2280.c:2788:	dev->gadget.dev.release = gadget_release;
net2280.c:2789:	dev->gadget.name = driver_name;
net2280.c:2793:   	        retval = -ENODEV;
net2280.c:2796:	dev->enabled = 1;
net2280.c:2806:		retval = -EBUSY;
net2280.c:2809:	dev->region = 1;
net2280.c:2814:		retval = -EFAULT;
net2280.c:2817:	dev->regs = (struct net2280_regs __iomem *) base;
net2280.c:2818:	dev->usb = (struct net2280_usb_regs __iomem *) (base + 0x0080);
net2280.c:2819:	dev->pci = (struct net2280_pci_regs __iomem *) (base + 0x0100);
net2280.c:2820:	dev->dma = (struct net2280_dma_regs __iomem *) (base + 0x0180);
net2280.c:2821:	dev->dep = (struct net2280_dep_regs __iomem *) (base + 0x0200);
net2280.c:2822:	dev->epregs = (struct net2280_ep_regs __iomem *) (base + 0x0300);
net2280.c:2825:	writel (0, &dev->usb->usbctl);
net2280.c:2830:	if (!pdev->irq) {
net2280.c:2832:		retval = -ENODEV;
net2280.c:2836:	scnprintf (buf, sizeof buf, "%d", pdev->irq);
net2280.c:2839:	bufp = __irq_itoa(pdev->irq);
net2280.c:2841:	if (request_irq (pdev->irq, net2280_irq, SA_SHIRQ, driver_name, dev)
net2280.c:2844:		retval = -EBUSY;
net2280.c:2847:	dev->got_irq = 1;
net2280.c:2851:	dev->requests = pci_pool_create ("requests", pdev,
net2280.c:2854:		0 /* or page-crossing issues */);
net2280.c:2855:	if (!dev->requests) {
net2280.c:2857:		retval = -ENOMEM;
net2280.c:2863:		td = pci_pool_alloc (dev->requests, GFP_KERNEL,
net2280.c:2864:				&dev->ep [i].td_dma);
net2280.c:2867:			retval = -ENOMEM;
net2280.c:2870:		td->dmacount = 0;	/* not VALID */
net2280.c:2871:		td->dmaaddr = __constant_cpu_to_le32 (DMA_ADDR_INVALID);
net2280.c:2872:		td->dmadesc = td->dmaaddr;
net2280.c:2873:		dev->ep [i].dummy = td;
net2280.c:2876:	/* enable lower-overhead pci memory bursts during DMA */
net2280.c:2882:			, &dev->pci->pcimstctl);
net2280.c:2888:	dev->chiprev = get_idx_reg (dev->regs, REG_CHIPREV) & 0xffff;
net2280.c:2894:			bufp, base, dev->chiprev);
net2280.c:2901:	device_register (&dev->gadget.dev);
net2280.c:2902:	device_create_file (&pdev->dev, &dev_attr_registers);
net2280.c:2913:/*-------------------------------------------------------------------------*/
omap_udc.c:2: * omap_udc.c -- for OMAP full speed udc; most chips support OTG.
omap_udc.c:19: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
omap_udc.c:45:#include <linux/dma-mapping.h>
omap_udc.c:52:#include <asm/mach-types.h>
omap_udc.c:85: * initialization to choose among a set of pre-defined endpoint configs.
omap_udc.c:124:/*-------------------------------------------------------------------------*/
omap_udc.c:132:	u16	num = ep->bEndpointAddress & 0x0f;
omap_udc.c:134:	if (ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:148:/*-------------------------------------------------------------------------*/
omap_udc.c:159:	if (!_ep || !desc || ep->desc
omap_udc.c:160:			|| desc->bDescriptorType != USB_DT_ENDPOINT
omap_udc.c:161:			|| ep->bEndpointAddress != desc->bEndpointAddress
omap_udc.c:162:			|| ep->maxpacket < le16_to_cpu
omap_udc.c:163:						(desc->wMaxPacketSize)) {
omap_udc.c:165:		return -EINVAL;
omap_udc.c:167:	maxp = le16_to_cpu (desc->wMaxPacketSize);
omap_udc.c:168:	if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
omap_udc.c:169:				&& maxp != ep->maxpacket)
omap_udc.c:170:			|| desc->wMaxPacketSize > ep->maxpacket
omap_udc.c:171:			|| !desc->wMaxPacketSize) {
omap_udc.c:172:		DBG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
omap_udc.c:173:		return -ERANGE;
omap_udc.c:177:	if ((desc->bmAttributes == USB_ENDPOINT_XFER_ISOC
omap_udc.c:178:				&& desc->bInterval != 1)) {
omap_udc.c:179:		/* hardware wants period = 1; USB allows 2^(Interval-1) */
omap_udc.c:180:		DBG("%s, unsupported ISO period %dms\n", _ep->name,
omap_udc.c:181:				1 << (desc->bInterval - 1));
omap_udc.c:182:		return -EDOM;
omap_udc.c:185:	if (desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
omap_udc.c:186:		DBG("%s, ISO nyet\n", _ep->name);
omap_udc.c:187:		return -EDOM;
omap_udc.c:192:	if (ep->bmAttributes != desc->bmAttributes
omap_udc.c:193:			&& ep->bmAttributes != USB_ENDPOINT_XFER_BULK
omap_udc.c:194:			&& desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
omap_udc.c:195:		DBG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
omap_udc.c:196:		return -EINVAL;
omap_udc.c:199:	udc = ep->udc;
omap_udc.c:200:	if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
omap_udc.c:202:		return -ESHUTDOWN;
omap_udc.c:205:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:207:	ep->desc = desc;
omap_udc.c:208:	ep->irqs = 0;
omap_udc.c:209:	ep->stopped = 0;
omap_udc.c:210:	ep->ep.maxpacket = maxp;
omap_udc.c:213:	ep->dma_channel = 0;
omap_udc.c:214:	ep->has_dma = 0;
omap_udc.c:215:	ep->lch = -1;
omap_udc.c:218:	ep->ackwait = 0;
omap_udc.c:221:	if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
omap_udc.c:222:		list_add(&ep->iso, &udc->iso);
omap_udc.c:225:	if (use_dma && desc->bmAttributes == USB_ENDPOINT_XFER_BULK)
omap_udc.c:230:	if (desc->bmAttributes != USB_ENDPOINT_XFER_ISOC
omap_udc.c:231:			&& !ep->has_dma
omap_udc.c:232:			&& !(ep->bEndpointAddress & USB_DIR_IN)) {
omap_udc.c:234:		ep->ackwait = 1 + ep->double_buf;
omap_udc.c:237:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:238:	VDBG("%s enabled\n", _ep->name);
omap_udc.c:249:	if (!_ep || !ep->desc) {
omap_udc.c:251:			_ep ? ep->ep.name : NULL);
omap_udc.c:252:		return -EINVAL;
omap_udc.c:255:	spin_lock_irqsave(&ep->udc->lock, flags);
omap_udc.c:256:	ep->desc = 0;
omap_udc.c:257:	nuke (ep, -ESHUTDOWN);
omap_udc.c:258:	ep->ep.maxpacket = ep->maxpacket;
omap_udc.c:259:	ep->has_dma = 0;
omap_udc.c:261:	list_del_init(&ep->iso);
omap_udc.c:262:	del_timer(&ep->timer);
omap_udc.c:264:	spin_unlock_irqrestore(&ep->udc->lock, flags);
omap_udc.c:266:	VDBG("%s disabled\n", _ep->name);
omap_udc.c:270:/*-------------------------------------------------------------------------*/
omap_udc.c:280:		req->req.dma = DMA_ADDR_INVALID;
omap_udc.c:281:		INIT_LIST_HEAD (&req->queue);
omap_udc.c:283:	return &req->req;
omap_udc.c:295:/*-------------------------------------------------------------------------*/
omap_udc.c:309:	if (use_dma && ep->has_dma) {
omap_udc.c:312:			dev_warn(ep->udc->gadget.dev.parent,
omap_udc.c:317:		return dma_alloc_coherent(ep->udc->gadget.dev.parent,
omap_udc.c:337:	if (use_dma && _ep && ep->has_dma)
omap_udc.c:338:		dma_free_coherent(ep->udc->gadget.dev.parent, bytes, buf, dma);
omap_udc.c:343:/*-------------------------------------------------------------------------*/
omap_udc.c:348:	unsigned		stopped = ep->stopped;
omap_udc.c:350:	list_del_init(&req->queue);
omap_udc.c:352:	if (req->req.status == -EINPROGRESS)
omap_udc.c:353:		req->req.status = status;
omap_udc.c:355:		status = req->req.status;
omap_udc.c:357:	if (use_dma && ep->has_dma) {
omap_udc.c:358:		if (req->mapped) {
omap_udc.c:359:			dma_unmap_single(ep->udc->gadget.dev.parent,
omap_udc.c:360:				req->req.dma, req->req.length,
omap_udc.c:361:				(ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:364:			req->req.dma = DMA_ADDR_INVALID;
omap_udc.c:365:			req->mapped = 0;
omap_udc.c:367:			dma_sync_single_for_cpu(ep->udc->gadget.dev.parent,
omap_udc.c:368:				req->req.dma, req->req.length,
omap_udc.c:369:				(ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:375:	if (status && status != -ESHUTDOWN)
omap_udc.c:378:			ep->ep.name, &req->req, status,
omap_udc.c:379:			req->req.actual, req->req.length);
omap_udc.c:382:	ep->stopped = 1;
omap_udc.c:383:	spin_unlock(&ep->udc->lock);
omap_udc.c:384:	req->req.complete(&ep->ep, &req->req);
omap_udc.c:385:	spin_lock(&ep->udc->lock);
omap_udc.c:386:	ep->stopped = stopped;
omap_udc.c:389:/*-------------------------------------------------------------------------*/
omap_udc.c:403:	len = min(req->req.length - req->req.actual, max);
omap_udc.c:404:	req->req.actual += len;
omap_udc.c:411:			max -= 2;
omap_udc.c:415:	while (max--)
omap_udc.c:431:	buf = req->req.buf + req->req.actual;
omap_udc.c:434:	/* PIO-IN isn't double buffered except for iso */
omap_udc.c:439:	count = ep->ep.maxpacket;
omap_udc.c:442:	ep->ackwait = 1;
omap_udc.c:445:	if (count != ep->ep.maxpacket)
omap_udc.c:447:	else if (req->req.length == req->req.actual
omap_udc.c:448:			&& !req->req.zero)
omap_udc.c:468:	len = min(req->req.length - req->req.actual, avail);
omap_udc.c:469:	req->req.actual += len;
omap_udc.c:476:			avail -= 2;
omap_udc.c:480:	while (avail--)
omap_udc.c:492:	buf = req->req.buf + req->req.actual;
omap_udc.c:500:			if (!ep->double_buf)
omap_udc.c:502:			ep->fnf = 1;
omap_udc.c:508:			avail = ep->ep.maxpacket;
omap_udc.c:511:			ep->fnf = ep->double_buf;
omap_udc.c:516:		if (count < ep->ep.maxpacket) {
omap_udc.c:520:				req->req.status = -EOVERFLOW;
omap_udc.c:521:				avail -= count;
omap_udc.c:522:				while (avail--)
omap_udc.c:525:		} else if (req->req.length == req->req.actual)
omap_udc.c:530:		if (!ep->bEndpointAddress)
omap_udc.c:539:/*-------------------------------------------------------------------------*/
omap_udc.c:545:	/* IN-DMA needs this on fault/cancel paths, so 15xx misreports
omap_udc.c:551:	end = omap_readw(OMAP_DMA_CSAC(ep->lch));
omap_udc.c:552:	if (end == ep->dma_counter)
omap_udc.c:558:	return end - start;
omap_udc.c:569:	end = omap_readw(DMA_DEST_LAST(ep->lch));
omap_udc.c:570:	if (end == ep->dma_counter)
omap_udc.c:578:	return end - start;
omap_udc.c:590:	unsigned	length = req->req.length - req->req.actual;
omap_udc.c:597:			|| (cpu_is_omap15xx() && length < ep->maxpacket)) {
omap_udc.c:599:		omap_set_dma_transfer_params(ep->lch, OMAP_DMA_DATA_TYPE_S8,
omap_udc.c:602:		length = min(length / ep->maxpacket,
omap_udc.c:605:		omap_set_dma_transfer_params(ep->lch, OMAP_DMA_DATA_TYPE_S8,
omap_udc.c:606:				ep->ep.maxpacket, length, sync_mode);
omap_udc.c:607:		length *= ep->maxpacket;
omap_udc.c:609:	omap_set_dma_src_params(ep->lch, OMAP_DMA_PORT_EMIFF,
omap_udc.c:610:		OMAP_DMA_AMODE_POST_INC, req->req.dma + req->req.actual);
omap_udc.c:612:	omap_start_dma(ep->lch);
omap_udc.c:613:	ep->dma_counter = omap_readw(OMAP_DMA_CSAC(ep->lch));
omap_udc.c:614:	UDC_DMA_IRQ_EN_REG |= UDC_TX_DONE_IE(ep->dma_channel);
omap_udc.c:615:	UDC_TXDMA_REG(ep->dma_channel) = UDC_TXN_START | txdma_ctrl;
omap_udc.c:616:	req->dma_bytes = length;
omap_udc.c:622:		req->req.actual += req->dma_bytes;
omap_udc.c:625:		if (req->req.actual < req->req.length)
omap_udc.c:627:		if (req->req.zero
omap_udc.c:628:				&& req->dma_bytes != 0
omap_udc.c:629:				&& (req->req.actual % ep->maxpacket) == 0)
omap_udc.c:632:		req->req.actual += dma_src_len(ep, req->req.dma
omap_udc.c:633:							+ req->req.actual);
omap_udc.c:636:	omap_stop_dma(ep->lch);
omap_udc.c:637:	UDC_DMA_IRQ_EN_REG &= ~UDC_TX_DONE_IE(ep->dma_channel);
omap_udc.c:650:	packets = (req->req.length - req->req.actual) / ep->ep.maxpacket;
omap_udc.c:652:	req->dma_bytes = packets * ep->ep.maxpacket;
omap_udc.c:653:	omap_set_dma_transfer_params(ep->lch, OMAP_DMA_DATA_TYPE_S8,
omap_udc.c:654:			ep->ep.maxpacket, packets,
omap_udc.c:656:	omap_set_dma_dest_params(ep->lch, OMAP_DMA_PORT_EMIFF,
omap_udc.c:657:		OMAP_DMA_AMODE_POST_INC, req->req.dma + req->req.actual);
omap_udc.c:658:	ep->dma_counter = omap_readw(DMA_DEST_LAST(ep->lch));
omap_udc.c:660:	UDC_RXDMA_REG(ep->dma_channel) = UDC_RXN_STOP | (packets - 1);
omap_udc.c:661:	UDC_DMA_IRQ_EN_REG |= UDC_RX_EOT_IE(ep->dma_channel);
omap_udc.c:662:	UDC_EP_NUM_REG = (ep->bEndpointAddress & 0xf);
omap_udc.c:665:	omap_start_dma(ep->lch);
omap_udc.c:674:		ep->dma_counter = (u16) (req->req.dma + req->req.actual);
omap_udc.c:675:	count = dma_dest_len(ep, req->req.dma + req->req.actual);
omap_udc.c:676:	count += req->req.actual;
omap_udc.c:677:	if (count <= req->req.length)
omap_udc.c:678:		req->req.actual = count;
omap_udc.c:680:	if (count != req->dma_bytes || status)
omap_udc.c:681:		omap_stop_dma(ep->lch);
omap_udc.c:684:	else if (req->req.actual < req->req.length)
omap_udc.c:688:	UDC_DMA_IRQ_EN_REG &= ~UDC_RX_EOT_IE(ep->dma_channel);
omap_udc.c:700:		ep = &udc->ep[16 + UDC_DMA_TX_SRC(dman_stat)];
omap_udc.c:701:		ep->irqs++;
omap_udc.c:703:		if (!list_empty(&ep->queue)) {
omap_udc.c:704:			req = container_of(ep->queue.next,
omap_udc.c:710:		if (!list_empty (&ep->queue)) {
omap_udc.c:711:			req = container_of(ep->queue.next,
omap_udc.c:719:		ep = &udc->ep[UDC_DMA_RX_SRC(dman_stat)];
omap_udc.c:720:		ep->irqs++;
omap_udc.c:722:		if (!list_empty(&ep->queue)) {
omap_udc.c:723:			req = container_of(ep->queue.next,
omap_udc.c:729:		if (!list_empty (&ep->queue)) {
omap_udc.c:730:			req = container_of(ep->queue.next,
omap_udc.c:737:		ep = &udc->ep[UDC_DMA_RX_SRC(dman_stat)];
omap_udc.c:738:		ep->irqs++;
omap_udc.c:740:		VDBG("%s, RX_CNT irq?\n", ep->ep.name);
omap_udc.c:751:	ERR("%s dma error, lch %d status %02x\n", ep->ep.name, lch, ch_status);
omap_udc.c:761:	is_in = ep->bEndpointAddress & USB_DIR_IN;
omap_udc.c:768:	ep->dma_channel = 0;
omap_udc.c:769:	ep->lch = -1;
omap_udc.c:778:			status = -EMLINK;
omap_udc.c:782:	reg |= (0x0f & ep->bEndpointAddress) << (4 * (channel - 1));
omap_udc.c:783:	ep->dma_channel = channel;
omap_udc.c:786:		status = omap_request_dma(OMAP_DMA_USB_W2FC_TX0 - 1 + channel,
omap_udc.c:787:			ep->ep.name, dma_error, ep, &ep->lch);
omap_udc.c:790:			omap_set_dma_dest_params(ep->lch,
omap_udc.c:796:		status = omap_request_dma(OMAP_DMA_USB_W2FC_RX0 - 1 + channel,
omap_udc.c:797:			ep->ep.name, dma_error, ep, &ep->lch);
omap_udc.c:800:			omap_set_dma_src_params(ep->lch,
omap_udc.c:807:		ep->dma_channel = 0;
omap_udc.c:809:		ep->has_dma = 1;
omap_udc.c:810:		omap_disable_dma_irq(ep->lch, OMAP_DMA_BLOCK_IRQ);
omap_udc.c:814:			omap_writew(2, OMAP_DMA_LCH_CTRL(ep->lch));
omap_udc.c:819:	restart = !ep->stopped && !list_empty(&ep->queue);
omap_udc.c:822:		DBG("%s no dma channel: %d%s\n", ep->ep.name, status,
omap_udc.c:825:		DBG("%s claimed %cxdma%d lch %d%s\n", ep->ep.name,
omap_udc.c:827:			ep->dma_channel - 1, ep->lch,
omap_udc.c:832:		req = container_of(ep->queue.next, struct omap_req, queue);
omap_udc.c:833:		if (ep->has_dma)
omap_udc.c:841:				ep->ackwait = 1 + ep->double_buf;
omap_udc.c:850:	int		shift = 4 * (ep->dma_channel - 1);
omap_udc.c:856:	if (!list_empty(&ep->queue))
omap_udc.c:857:		req = container_of(ep->queue.next, struct omap_req, queue);
omap_udc.c:861:	active = ((1 << 7) & omap_readl(OMAP_DMA_CCR(ep->lch))) != 0;
omap_udc.c:863:	DBG("%s release %s %cxdma%d %p\n", ep->ep.name,
omap_udc.c:865:			(ep->bEndpointAddress & USB_DIR_IN) ? 't' : 'r',
omap_udc.c:866:			ep->dma_channel - 1, req);
omap_udc.c:869:	if (ep->bEndpointAddress & USB_DIR_IN) {
omap_udc.c:873:			finish_in_dma(ep, req, -ECONNRESET);
omap_udc.c:889:			finish_out_dma(ep, req, -ECONNRESET);
omap_udc.c:891:	omap_free_dma(ep->lch);
omap_udc.c:892:	ep->dma_channel = 0;
omap_udc.c:893:	ep->lch = -1;
omap_udc.c:898:/*-------------------------------------------------------------------------*/
omap_udc.c:910:	if (!_req || !req->req.complete || !req->req.buf
omap_udc.c:911:			|| !list_empty(&req->queue)) {
omap_udc.c:913:		return -EINVAL;
omap_udc.c:915:	if (!_ep || (!ep->desc && ep->bEndpointAddress)) {
omap_udc.c:917:		return -EINVAL;
omap_udc.c:919:	if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
omap_udc.c:920:		if (req->req.length > ep->ep.maxpacket)
omap_udc.c:921:			return -EMSGSIZE;
omap_udc.c:929:			&& ep->has_dma
omap_udc.c:930:			&& ep->bEndpointAddress != 0
omap_udc.c:931:			&& (ep->bEndpointAddress & USB_DIR_IN) == 0
omap_udc.c:932:			&& (req->req.length % ep->ep.maxpacket) != 0) {
omap_udc.c:934:		return -EMSGSIZE;
omap_udc.c:937:	udc = ep->udc;
omap_udc.c:938:	if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
omap_udc.c:939:		return -ESHUTDOWN;
omap_udc.c:941:	if (use_dma && ep->has_dma) {
omap_udc.c:942:		if (req->req.dma == DMA_ADDR_INVALID) {
omap_udc.c:943:			req->req.dma = dma_map_single(
omap_udc.c:944:				ep->udc->gadget.dev.parent,
omap_udc.c:945:				req->req.buf,
omap_udc.c:946:				req->req.length,
omap_udc.c:947:				(ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:950:			req->mapped = 1;
omap_udc.c:953:				ep->udc->gadget.dev.parent,
omap_udc.c:954:				req->req.dma, req->req.length,
omap_udc.c:955:				(ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:958:			req->mapped = 0;
omap_udc.c:963:		ep->ep.name, _req, _req->length, _req->buf);
omap_udc.c:965:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:967:	req->req.status = -EINPROGRESS;
omap_udc.c:968:	req->req.actual = 0;
omap_udc.c:970:	/* maybe kickstart non-iso i/o queues */
omap_udc.c:973:	else if (list_empty(&ep->queue) && !ep->stopped && !ep->ackwait) {
omap_udc.c:976:		if (ep->bEndpointAddress == 0) {
omap_udc.c:977:			if (!udc->ep0_pending || !list_empty (&ep->queue)) {
omap_udc.c:978:				spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:979:				return -EL2HLT;
omap_udc.c:983:			is_in = udc->ep0_in;
omap_udc.c:984:			if (!req->req.length) {
omap_udc.c:988:				 * requests to non-control endpoints
omap_udc.c:990:				if (udc->ep0_set_config) {
omap_udc.c:994:					if (!udc->ep0_reset_config)
omap_udc.c:1006:				UDC_EP_NUM_REG = udc->ep0_in ? 0 : UDC_EP_DIR;
omap_udc.c:1009:				udc->ep0_pending = 0;
omap_udc.c:1013:			/* non-empty DATA stage */
omap_udc.c:1017:				if (udc->ep0_setup)
omap_udc.c:1022:			is_in = ep->bEndpointAddress & USB_DIR_IN;
omap_udc.c:1023:			if (!ep->has_dma)
omap_udc.c:1028:		if (ep->has_dma)
omap_udc.c:1036:				ep->ackwait = 1 + ep->double_buf;
omap_udc.c:1045:		list_add_tail(&req->queue, &ep->queue);
omap_udc.c:1046:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1058:		return -EINVAL;
omap_udc.c:1060:	spin_lock_irqsave(&ep->udc->lock, flags);
omap_udc.c:1063:	list_for_each_entry (req, &ep->queue, queue) {
omap_udc.c:1064:		if (&req->req == _req)
omap_udc.c:1067:	if (&req->req != _req) {
omap_udc.c:1068:		spin_unlock_irqrestore(&ep->udc->lock, flags);
omap_udc.c:1069:		return -EINVAL;
omap_udc.c:1072:	if (use_dma && ep->dma_channel && ep->queue.next == &req->queue) {
omap_udc.c:1073:		int channel = ep->dma_channel;
omap_udc.c:1081:		done(ep, req, -ECONNRESET);
omap_udc.c:1082:	spin_unlock_irqrestore(&ep->udc->lock, flags);
omap_udc.c:1086:/*-------------------------------------------------------------------------*/
omap_udc.c:1092:	int		status = -EOPNOTSUPP;
omap_udc.c:1094:	spin_lock_irqsave(&ep->udc->lock, flags);
omap_udc.c:1097:	if (ep->bEndpointAddress == 0) {
omap_udc.c:1098:		if (!ep->udc->ep0_pending)
omap_udc.c:1099:			status = -EINVAL;
omap_udc.c:1101:			if (ep->udc->ep0_set_config) {
omap_udc.c:1106:			ep->udc->ep0_pending = 0;
omap_udc.c:1111:	/* otherwise, all active non-ISO endpoints can halt */
omap_udc.c:1112:	} else if (ep->bmAttributes != USB_ENDPOINT_XFER_ISOC && ep->desc) {
omap_udc.c:1115:		if ((ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:1116:				&& !list_empty(&ep->queue)) { 
omap_udc.c:1117:			status = -EAGAIN;
omap_udc.c:1124:			if (use_dma && ep->dma_channel
omap_udc.c:1125:					&& !list_empty(&ep->queue)) {
omap_udc.c:1126:				channel = ep->dma_channel;
omap_udc.c:1136:				status = -EAGAIN;
omap_udc.c:1144:			ep->ackwait = 0;
omap_udc.c:1145:			if (!(ep->bEndpointAddress & USB_DIR_IN)) {
omap_udc.c:1147:				ep->ackwait = 1 + ep->double_buf;
omap_udc.c:1152:	VDBG("%s %s halt stat %d\n", ep->ep.name,
omap_udc.c:1155:	spin_unlock_irqrestore(&ep->udc->lock, flags);
omap_udc.c:1177:/*-------------------------------------------------------------------------*/
omap_udc.c:1182:	return (sof & UDC_TS_OK) ? (sof & UDC_TS) : -EL2NSYNC;
omap_udc.c:1189:	int		retval = -EHOSTUNREACH;
omap_udc.c:1193:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1194:	if (udc->devstat & UDC_SUS) {
omap_udc.c:1198:		if (udc->devstat & (UDC_B_HNP_ENABLE|UDC_R_WK_OK)) {
omap_udc.c:1204:	/* NOTE:  non-OTG systems may use SRP TOO... */
omap_udc.c:1205:	} else if (!(udc->devstat & UDC_ATT)) {
omap_udc.c:1206:		if (udc->transceiver)
omap_udc.c:1207:			retval = otg_start_srp(udc->transceiver);
omap_udc.c:1209:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1222:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1229:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1236:	return udc->driver && udc->softconnect && udc->vbus_active;
omap_udc.c:1269:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1271:	udc->vbus_active = (is_active != 0);
omap_udc.c:1283:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1292:	if (udc->transceiver)
omap_udc.c:1293:		return otg_set_power(udc->transceiver, mA);
omap_udc.c:1294:	return -EOPNOTSUPP;
omap_udc.c:1303:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1304:	udc->softconnect = (is_on != 0);
omap_udc.c:1309:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1322:/*-------------------------------------------------------------------------*/
omap_udc.c:1324:/* dequeue ALL requests; caller holds udc->lock */
omap_udc.c:1329:	ep->stopped = 1;
omap_udc.c:1331:	if (use_dma && ep->dma_channel)
omap_udc.c:1336:	if (ep->bEndpointAddress && ep->bmAttributes != USB_ENDPOINT_XFER_ISOC)
omap_udc.c:1339:	while (!list_empty(&ep->queue)) {
omap_udc.c:1340:		req = list_entry(ep->queue.next, struct omap_req, queue);
omap_udc.c:1345:/* caller holds udc->lock */
omap_udc.c:1350:	udc->gadget.speed = USB_SPEED_UNKNOWN;
omap_udc.c:1351:	nuke(&udc->ep[0], -ESHUTDOWN);
omap_udc.c:1352:	list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list)
omap_udc.c:1353:		nuke(ep, -ESHUTDOWN);
omap_udc.c:1356:/*-------------------------------------------------------------------------*/
omap_udc.c:1362:	if (!udc->gadget.is_otg)
omap_udc.c:1370:	udc->gadget.b_hnp_enable = !!(devstat & UDC_B_HNP_ENABLE);
omap_udc.c:1371:	udc->gadget.a_hnp_support = !!(devstat & UDC_A_HNP_SUPPORT);
omap_udc.c:1372:	udc->gadget.a_alt_hnp_support = !!(devstat & UDC_A_ALT_HNP_SUPPORT);
omap_udc.c:1377:	if (udc->gadget.b_hnp_enable)
omap_udc.c:1384:	struct omap_ep	*ep0 = &udc->ep[0];
omap_udc.c:1387:	ep0->irqs++;
omap_udc.c:1410:	if (!list_empty(&ep0->queue))
omap_udc.c:1411:		req = container_of(ep0->queue.next, struct omap_req, queue);
omap_udc.c:1421:			if (udc->ep0_in) {
omap_udc.c:1428:				if (!req && udc->ep0_pending) {
omap_udc.c:1433:					udc->ep0_pending = 0;
omap_udc.c:1458:			if (!udc->ep0_in) {
omap_udc.c:1465:					udc->ep0_pending = 0;
omap_udc.c:1479:					udc->ep0_pending = 0;
omap_udc.c:1501:		int			status = -EINVAL;
omap_udc.c:1522:		udc->ep0_in = (u.r.bRequestType & USB_DIR_IN) != 0;
omap_udc.c:1523:		udc->ep0_set_config = 0;
omap_udc.c:1524:		udc->ep0_pending = 1;
omap_udc.c:1525:		ep0->stopped = 0;
omap_udc.c:1526:		ep0->ackwait = 0;
omap_udc.c:1534:			udc->ep0_set_config = 1;
omap_udc.c:1535:			udc->ep0_reset_config = (u.r.wValue == 0);
omap_udc.c:1542:			if (udc->ep0_reset_config)
omap_udc.c:1555:			ep = &udc->ep[u.r.wIndex & 0xf];
omap_udc.c:1559:				if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
omap_udc.c:1560:						|| !ep->desc)
omap_udc.c:1564:				ep->ackwait = 0;
omap_udc.c:1565:				if (!(ep->bEndpointAddress & USB_DIR_IN)) {
omap_udc.c:1567:					ep->ackwait = 1 + ep->double_buf;
omap_udc.c:1570:			VDBG("%s halt cleared by host\n", ep->name);
omap_udc.c:1579:			ep = &udc->ep[u.r.wIndex & 0xf];
omap_udc.c:1582:			if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
omap_udc.c:1583:					|| ep == ep0 || !ep->desc)
omap_udc.c:1585:			if (use_dma && ep->has_dma) {
omap_udc.c:1586:				/* this has rude side-effects (aborts) and
omap_udc.c:1587:				 * can't really work if DMA-IN is active
omap_udc.c:1589:				DBG("%s host set_halt, NYET \n", ep->name);
omap_udc.c:1596:			VDBG("%s halted by host\n", ep->name);
omap_udc.c:1603:			udc->ep0_pending = 0;
omap_udc.c:1607:			 * we'd detect non-existent interfaces, and stall.
omap_udc.c:1624:			if (!udc->ep0_in && u.r.wLength) {
omap_udc.c:1648:			udc->ep0_setup = 1;
omap_udc.c:1649:			spin_unlock(&udc->lock);
omap_udc.c:1650:			status = udc->driver->setup (&udc->gadget, &u.r);
omap_udc.c:1651:			spin_lock(&udc->lock);
omap_udc.c:1652:			udc->ep0_setup = 0;
omap_udc.c:1659:			if (udc->ep0_set_config) {
omap_udc.c:1660:				if (udc->ep0_reset_config)
omap_udc.c:1666:			udc->ep0_pending = 0;
omap_udc.c:1671:/*-------------------------------------------------------------------------*/
omap_udc.c:1680:	change = devstat ^ udc->devstat;
omap_udc.c:1681:	udc->devstat = devstat;
omap_udc.c:1691:				udc->gadget.speed = USB_SPEED_FULL;
omap_udc.c:1693:				if (!udc->transceiver)
omap_udc.c:1695:				// if (driver->connect) call it
omap_udc.c:1696:			} else if (udc->gadget.speed != USB_SPEED_UNKNOWN) {
omap_udc.c:1697:				udc->gadget.speed = USB_SPEED_UNKNOWN;
omap_udc.c:1698:				if (!udc->transceiver)
omap_udc.c:1701:					udc->driver->driver.name);
omap_udc.c:1702:				if (udc->driver->disconnect) {
omap_udc.c:1703:					spin_unlock(&udc->lock);
omap_udc.c:1704:					udc->driver->disconnect(&udc->gadget);
omap_udc.c:1705:					spin_lock(&udc->lock);
omap_udc.c:1715:				udc->gadget.speed = USB_SPEED_FULL;
omap_udc.c:1717:					udc->driver->driver.name);
omap_udc.c:1725:		if (udc->gadget.speed != USB_SPEED_UNKNOWN) {
omap_udc.c:1731:				if (udc->gadget.speed == USB_SPEED_FULL
omap_udc.c:1732:						&& udc->driver->suspend) {
omap_udc.c:1733:					spin_unlock(&udc->lock);
omap_udc.c:1734:					udc->driver->suspend(&udc->gadget);
omap_udc.c:1735:					spin_lock(&udc->lock);
omap_udc.c:1739:				if (udc->gadget.speed == USB_SPEED_FULL
omap_udc.c:1740:						&& udc->driver->resume) {
omap_udc.c:1741:					spin_unlock(&udc->lock);
omap_udc.c:1742:					udc->driver->resume(&udc->gadget);
omap_udc.c:1743:					spin_lock(&udc->lock);
omap_udc.c:1770:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1797:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1802:/* workaround for seemingly-lost IRQs for RX ACKs... */
omap_udc.c:1812:	spin_lock_irqsave(&ep->udc->lock, flags);
omap_udc.c:1813:	if (!list_empty(&ep->queue) && ep->ackwait) {
omap_udc.c:1818:				|| (ep->double_buf && HALF_FULL(stat_flg)))) {
omap_udc.c:1821:			VDBG("%s: lose, %04x\n", ep->ep.name, stat_flg);
omap_udc.c:1822:			req = container_of(ep->queue.next,
omap_udc.c:1824:			UDC_EP_NUM_REG = ep->bEndpointAddress | UDC_EP_SEL;
omap_udc.c:1826:			UDC_EP_NUM_REG = ep->bEndpointAddress;
omap_udc.c:1828:			ep->ackwait = 1 + ep->double_buf;
omap_udc.c:1831:	mod_timer(&ep->timer, PIO_OUT_TIMEOUT);
omap_udc.c:1832:	spin_unlock_irqrestore(&ep->udc->lock, flags);
omap_udc.c:1846:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1855:		ep = &udc->ep[epnum];
omap_udc.c:1856:		ep->irqs++;
omap_udc.c:1859:		ep->fnf = 0;
omap_udc.c:1861:			ep->ackwait--;
omap_udc.c:1862:			if (!list_empty(&ep->queue)) {
omap_udc.c:1864:				req = container_of(ep->queue.next,
omap_udc.c:1867:				if (!ep->double_buf)
omap_udc.c:1868:					ep->fnf = 1;
omap_udc.c:1879:		if (ep->fnf) {
omap_udc.c:1881:			ep->ackwait = 1 + ep->double_buf;
omap_udc.c:1883:		mod_timer(&ep->timer, PIO_OUT_TIMEOUT);
omap_udc.c:1891:		ep = &udc->ep[16 + epnum];
omap_udc.c:1892:		ep->irqs++;
omap_udc.c:1896:			ep->ackwait = 0;
omap_udc.c:1897:			if (!list_empty(&ep->queue)) {
omap_udc.c:1898:				req = container_of(ep->queue.next,
omap_udc.c:1910:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1923:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1925:	/* handle all non-DMA ISO transfers */
omap_udc.c:1926:	list_for_each_entry (ep, &udc->iso, iso) {
omap_udc.c:1930:		if (ep->has_dma || list_empty(&ep->queue))
omap_udc.c:1932:		req = list_entry(ep->queue.next, struct omap_req, queue);
omap_udc.c:1940:		if (ep->bEndpointAddress & USB_DIR_IN) {
omap_udc.c:1942:				/* done(ep, req, -EPROTO) */;
omap_udc.c:1949:				status = -EREMOTEIO;
omap_udc.c:1951:				status = -EILSEQ;
omap_udc.c:1953:				status = -ENOSR;
omap_udc.c:1963:		ep->irqs++;
omap_udc.c:1964:		if (!list_empty(&ep->queue))
omap_udc.c:1971:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:1976:/*-------------------------------------------------------------------------*/
omap_udc.c:1982:	int		status = -ENODEV;
omap_udc.c:1988:		return -ENODEV;
omap_udc.c:1990:			// FIXME if otg, check:  driver->is_otg
omap_udc.c:1991:			|| driver->speed < USB_SPEED_FULL
omap_udc.c:1992:			|| !driver->bind
omap_udc.c:1993:			|| !driver->unbind
omap_udc.c:1994:			|| !driver->setup)
omap_udc.c:1995:		return -EINVAL;
omap_udc.c:1997:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:1998:	if (udc->driver) {
omap_udc.c:1999:		spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:2000:		return -EBUSY;
omap_udc.c:2004:	list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
omap_udc.c:2005:		ep->irqs = 0;
omap_udc.c:2006:		if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
omap_udc.c:2011:	udc->ep0_pending = 0;
omap_udc.c:2012:	udc->ep[0].irqs = 0;
omap_udc.c:2013:	udc->softconnect = 1;
omap_udc.c:2016:	driver->driver.bus = 0;
omap_udc.c:2017:	udc->driver = driver;
omap_udc.c:2018:	udc->gadget.dev.driver = &driver->driver;
omap_udc.c:2019:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:2021:	status = driver->bind (&udc->gadget);
omap_udc.c:2023:		DBG("bind to %s --> %d\n", driver->driver.name, status);
omap_udc.c:2024:		udc->gadget.dev.driver = 0;
omap_udc.c:2025:		udc->driver = 0;
omap_udc.c:2028:	DBG("bound to driver %s\n", driver->driver.name);
omap_udc.c:2033:	if (udc->transceiver) {
omap_udc.c:2034:		status = otg_set_peripheral(udc->transceiver, &udc->gadget);
omap_udc.c:2037:			driver->unbind (&udc->gadget);
omap_udc.c:2038:			udc->gadget.dev.driver = 0;
omap_udc.c:2039:			udc->driver = 0;
omap_udc.c:2050:		omap_vbus_session(&udc->gadget, 1);
omap_udc.c:2060:	int		status = -ENODEV;
omap_udc.c:2063:		return -ENODEV;
omap_udc.c:2064:	if (!driver || driver != udc->driver)
omap_udc.c:2065:		return -EINVAL;
omap_udc.c:2068:		omap_vbus_session(&udc->gadget, 0);
omap_udc.c:2070:	if (udc->transceiver)
omap_udc.c:2071:		(void) otg_set_peripheral(udc->transceiver, 0);
omap_udc.c:2075:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:2077:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:2079:	driver->unbind(&udc->gadget);
omap_udc.c:2080:	udc->gadget.dev.driver = 0;
omap_udc.c:2081:	udc->driver = 0;
omap_udc.c:2084:	DBG("unregistered driver '%s'\n", driver->driver.name);
omap_udc.c:2090:/*-------------------------------------------------------------------------*/
omap_udc.c:2109:	if (use_dma && ep->has_dma)
omap_udc.c:2111:			(ep->bEndpointAddress & USB_DIR_IN) ? 't' : 'r',
omap_udc.c:2112:			ep->dma_channel - 1, ep->lch);
omap_udc.c:2119:		ep->name, buf,
omap_udc.c:2120:		ep->double_buf ? "dbuf " : "",
omap_udc.c:2121:		({char *s; switch(ep->ackwait){
omap_udc.c:2127:		ep->irqs, stat_flg,
omap_udc.c:2142:	if (list_empty (&ep->queue))
omap_udc.c:2145:		list_for_each_entry (req, &ep->queue, queue) {
omap_udc.c:2146:			unsigned	length = req->req.actual;
omap_udc.c:2149:				length += ((ep->bEndpointAddress & USB_DIR_IN)
omap_udc.c:2151:					(ep, req->req.dma + length);
omap_udc.c:2155:					&req->req, length,
omap_udc.c:2156:					req->req.length, req->req.buf);
omap_udc.c:2240:	spin_lock_irqsave(&udc->lock, flags);
omap_udc.c:2256:		udc->driver ? udc->driver->driver.name : "(none)",
omap_udc.c:2258:		udc->transceiver ? udc->transceiver->label : "(none)");
omap_udc.c:2278:	// syscon2 is write-only
omap_udc.c:2283:		spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:2360:		proc_ep_show(s, &udc->ep[0]);
omap_udc.c:2362:			list_for_each_entry (ep, &udc->gadget.ep_list,
omap_udc.c:2364:				if (ep->desc)
omap_udc.c:2369:	spin_unlock_irqrestore(&udc->lock, flags);
omap_udc.c:2391:		pde->proc_fops = &proc_ops;
omap_udc.c:2406:/*-------------------------------------------------------------------------*/
omap_udc.c:2420:	ep = &udc->ep[addr & 0xf];
omap_udc.c:2425:	BUG_ON(ep->name[0]);
omap_udc.c:2442:		/* double-buffering "not supported" on 15xx,
omap_udc.c:2443:		 * and ignored for PIO-IN on 16xx
omap_udc.c:2457:		init_timer(&ep->timer);
omap_udc.c:2458:		ep->timer.function = pio_out_timer;
omap_udc.c:2459:		ep->timer.data = (unsigned long) ep;
omap_udc.c:2481:	BUG_ON(strlen(name) >= sizeof ep->name);
omap_udc.c:2482:	strlcpy(ep->name, name, sizeof ep->name);
omap_udc.c:2483:	INIT_LIST_HEAD(&ep->queue);
omap_udc.c:2484:	INIT_LIST_HEAD(&ep->iso);
omap_udc.c:2485:	ep->bEndpointAddress = addr;
omap_udc.c:2486:	ep->bmAttributes = type;
omap_udc.c:2487:	ep->double_buf = dbuf;
omap_udc.c:2488:	ep->udc = udc; 
omap_udc.c:2490:	ep->ep.name = ep->name;
omap_udc.c:2491:	ep->ep.ops = &omap_ep_ops;
omap_udc.c:2492:	ep->ep.maxpacket = ep->maxpacket = maxp;
omap_udc.c:2493:	list_add_tail (&ep->ep.ep_list, &udc->gadget.ep_list);
omap_udc.c:2500:	complete(udc->done);
omap_udc.c:2523:		return -ENOMEM;
omap_udc.c:2526:	spin_lock_init (&udc->lock);
omap_udc.c:2528:	udc->gadget.ops = &omap_gadget_ops;
omap_udc.c:2529:	udc->gadget.ep0 = &udc->ep[0].ep;
omap_udc.c:2530:	INIT_LIST_HEAD(&udc->gadget.ep_list);
omap_udc.c:2531:	INIT_LIST_HEAD(&udc->iso);
omap_udc.c:2532:	udc->gadget.speed = USB_SPEED_UNKNOWN;
omap_udc.c:2533:	udc->gadget.name = driver_name;
omap_udc.c:2535:	device_initialize(&udc->gadget.dev);
omap_udc.c:2536:	strcpy (udc->gadget.dev.bus_id, "gadget");
omap_udc.c:2537:	udc->gadget.dev.release = omap_udc_release;
omap_udc.c:2538:	udc->gadget.dev.parent = &odev->dev;
omap_udc.c:2540:		udc->gadget.dev.dma_mask = odev->dev.dma_mask;
omap_udc.c:2542:	udc->transceiver = xceiv;
omap_udc.c:2547:	list_del_init(&udc->ep[0].ep.ep_list);
omap_udc.c:2549:	/* initially disable all non-ep0 endpoints */
omap_udc.c:2556:	buf = omap_ep_setup(name "-bulk", addr, \
omap_udc.c:2559:	buf = omap_ep_setup(name "-int", addr, \
omap_udc.c:2562:	buf = omap_ep_setup(name "-iso", addr, \
omap_udc.c:2625:		return -ENODEV;
omap_udc.c:2628:	INFO("fifo mode %d, %d bytes not used\n", fifo_mode, 2048 - buf);
omap_udc.c:2635:	int			status = -ENODEV;
omap_udc.c:2639:	struct omap_usb_config	*config = dev->platform_data;
omap_udc.c:2642:	if (!request_mem_region(odev->resource[0].start, 
omap_udc.c:2643:			odev->resource[0].end - odev->resource[0].start + 1,
omap_udc.c:2646:		return -EBUSY;
omap_udc.c:2651:		config->otg ? ", Mini-AB" : "");
omap_udc.c:2683:				if (config->otg)
omap_udc.c:2687:				type = xceiv->label;
omap_udc.c:2704:			return -ENODEV;
omap_udc.c:2718:	udc->gadget.is_otg = (config->otg != 0);
omap_udc.c:2722:	status = request_irq(odev->resource[1].start, omap_udc_irq,
omap_udc.c:2726:			odev->resource[1].start, status);
omap_udc.c:2730:	/* USB "non-iso" IRQ (PIO for all but ep0) */
omap_udc.c:2731:	status = request_irq(odev->resource[2].start, omap_udc_pio_irq,
omap_udc.c:2735:			odev->resource[2].start, status);
omap_udc.c:2739:	status = request_irq(odev->resource[3].start, omap_udc_iso_irq,
omap_udc.c:2743:			odev->resource[3].start, status);
omap_udc.c:2749:	device_add(&udc->gadget.dev);
omap_udc.c:2754:	free_irq(odev->resource[2].start, udc);
omap_udc.c:2758:	free_irq(odev->resource[1].start, udc);
omap_udc.c:2766:		put_device(xceiv->dev);
omap_udc.c:2767:	release_mem_region(odev->resource[0].start,
omap_udc.c:2768:			odev->resource[0].end - odev->resource[0].start + 1);
omap_udc.c:2778:		return -ENODEV;
omap_udc.c:2780:	udc->done = &done;
omap_udc.c:2783:	if (udc->transceiver) {
omap_udc.c:2784:		put_device(udc->transceiver->dev);
omap_udc.c:2785:		udc->transceiver = 0;
omap_udc.c:2792:	free_irq(odev->resource[3].start, udc);
omap_udc.c:2794:	free_irq(odev->resource[2].start, udc);
omap_udc.c:2795:	free_irq(odev->resource[1].start, udc);
omap_udc.c:2797:	release_mem_region(odev->resource[0].start,
omap_udc.c:2798:			odev->resource[0].end - odev->resource[0].start + 1);
omap_udc.c:2800:	device_unregister(&udc->gadget.dev);
omap_udc.c:2814:	omap_pullup(&udc->gadget, 0);
omap_udc.c:2815:	udc->gadget.dev.power.power_state = 3;
omap_udc.c:2816:	udc->gadget.dev.parent->power.power_state = 3;
omap_udc.c:2826:	udc->gadget.dev.parent->power.power_state = 0;
omap_udc.c:2827:	udc->gadget.dev.power.power_state = 0;
omap_udc.c:2828:	omap_pullup(&udc->gadget, 1);
omap_udc.c:2832:	return omap_wakeup(&udc->gadget);
omap_udc.c:2835:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:3: * Intel PXA2xx and IXP4xx on-chip full speed USB device controllers
pxa2xx_udc.c:23: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
pxa2xx_udc.c:47:#include <linux/dma-mapping.h>
pxa2xx_udc.c:54:#include <asm/mach-types.h>
pxa2xx_udc.c:57:#include <asm/arch/pxa-regs.h>
pxa2xx_udc.c:82:#define	DRIVER_VERSION	"14-Dec-2003"
pxa2xx_udc.c:98:/* cpu-specific register addresses are compiled in to this code */
pxa2xx_udc.c:144:/* ---------------------------------------------------------------------------
pxa2xx_udc.c:146: *	used by gadget driver; and the inner talker-to-hardware core.
pxa2xx_udc.c:147: * ---------------------------------------------------------------------------
pxa2xx_udc.c:159:                bEndpointAddress -= 8;
pxa2xx_udc.c:170:                bEndpointAddress -= 8;
pxa2xx_udc.c:210: * iso endpoints must be in non-default altsettings.
pxa2xx_udc.c:219:	if (!_ep || !desc || ep->desc || _ep->name == ep0name
pxa2xx_udc.c:220:			|| desc->bDescriptorType != USB_DT_ENDPOINT
pxa2xx_udc.c:221:			|| ep->bEndpointAddress != desc->bEndpointAddress
pxa2xx_udc.c:222:			|| ep->fifo_size < le16_to_cpu
pxa2xx_udc.c:223:						(desc->wMaxPacketSize)) {
pxa2xx_udc.c:225:		return -EINVAL;
pxa2xx_udc.c:229:	if (ep->bmAttributes != desc->bmAttributes
pxa2xx_udc.c:230:			&& ep->bmAttributes != USB_ENDPOINT_XFER_BULK
pxa2xx_udc.c:231:			&& desc->bmAttributes != USB_ENDPOINT_XFER_INT) {
pxa2xx_udc.c:232:		DMSG("%s, %s type mismatch\n", __FUNCTION__, _ep->name);
pxa2xx_udc.c:233:		return -EINVAL;
pxa2xx_udc.c:237:	if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK
pxa2xx_udc.c:238:				&& le16_to_cpu (desc->wMaxPacketSize)
pxa2xx_udc.c:240:			|| !desc->wMaxPacketSize) {
pxa2xx_udc.c:241:		DMSG("%s, bad %s maxpacket\n", __FUNCTION__, _ep->name);
pxa2xx_udc.c:242:		return -ERANGE;
pxa2xx_udc.c:245:	dev = ep->dev;
pxa2xx_udc.c:246:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) {
pxa2xx_udc.c:248:		return -ESHUTDOWN;
pxa2xx_udc.c:251:	ep->desc = desc;
pxa2xx_udc.c:252:	ep->dma = -1;
pxa2xx_udc.c:253:	ep->stopped = 0;
pxa2xx_udc.c:254:	ep->pio_irqs = ep->dma_irqs = 0;
pxa2xx_udc.c:255:	ep->ep.maxpacket = le16_to_cpu (desc->wMaxPacketSize);
pxa2xx_udc.c:266:	switch (ep->bmAttributes) {
pxa2xx_udc.c:268:		if (le16_to_cpu(desc->wMaxPacketSize) % 32)
pxa2xx_udc.c:272:		if (!use_dma || !ep->reg_drcmr)
pxa2xx_udc.c:274:		ep->dma = pxa_request_dma ((char *)_ep->name,
pxa2xx_udc.c:275: 				(le16_to_cpu (desc->wMaxPacketSize) > 64)
pxa2xx_udc.c:279:		if (ep->dma >= 0) {
pxa2xx_udc.c:280:			*ep->reg_drcmr = DRCMR_MAPVLD | ep->dma;
pxa2xx_udc.c:281:			DMSG("%s using dma%d\n", _ep->name, ep->dma);
pxa2xx_udc.c:286:	DBG(DBG_VERBOSE, "enabled %s\n", _ep->name);
pxa2xx_udc.c:295:	if (!_ep || !ep->desc) {
pxa2xx_udc.c:297:			_ep ? ep->ep.name : NULL);
pxa2xx_udc.c:298:		return -EINVAL;
pxa2xx_udc.c:300:	nuke (ep, -ESHUTDOWN);
pxa2xx_udc.c:303:	if (ep->dma >= 0) {
pxa2xx_udc.c:304:		*ep->reg_drcmr = 0;
pxa2xx_udc.c:305:		pxa_free_dma (ep->dma);
pxa2xx_udc.c:306:		ep->dma = -1;
pxa2xx_udc.c:313:	ep->desc = 0;
pxa2xx_udc.c:314:	ep->stopped = 1;
pxa2xx_udc.c:316:	DBG(DBG_VERBOSE, "%s disabled\n", _ep->name);
pxa2xx_udc.c:320:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:328: * 	pxa2xx_ep_alloc_request - allocate a request data structure
pxa2xx_udc.c:340:	INIT_LIST_HEAD (&req->queue);
pxa2xx_udc.c:341:	return &req->req;
pxa2xx_udc.c:346: * 	pxa2xx_ep_free_request - deallocate a request data structure
pxa2xx_udc.c:354:	WARN_ON (!list_empty (&req->queue));
pxa2xx_udc.c:359:/* PXA cache needs flushing with DMA I/O (it's dma-incoherent), but there's
pxa2xx_udc.c:360: * no device-affinity and the heap works perfectly well for i/o buffers.
pxa2xx_udc.c:383:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:386: *	done - retire a request; caller blocked irqs
pxa2xx_udc.c:390:	unsigned		stopped = ep->stopped;
pxa2xx_udc.c:392:	list_del_init(&req->queue);
pxa2xx_udc.c:394:	if (likely (req->req.status == -EINPROGRESS))
pxa2xx_udc.c:395:		req->req.status = status;
pxa2xx_udc.c:397:		status = req->req.status;
pxa2xx_udc.c:399:	if (status && status != -ESHUTDOWN)
pxa2xx_udc.c:401:			ep->ep.name, &req->req, status,
pxa2xx_udc.c:402:			req->req.actual, req->req.length);
pxa2xx_udc.c:405:	ep->stopped = 1;
pxa2xx_udc.c:406:	req->req.complete(&ep->ep, &req->req);
pxa2xx_udc.c:407:	ep->stopped = stopped;
pxa2xx_udc.c:413:	dev->ep0state = EP0_IDLE;
pxa2xx_udc.c:423:	buf = req->req.buf + req->req.actual;
pxa2xx_udc.c:427:	length = min(req->req.length - req->req.actual, max);
pxa2xx_udc.c:428:	req->req.actual += length;
pxa2xx_udc.c:431:	while (likely(count--))
pxa2xx_udc.c:447:	max = le16_to_cpu(ep->desc->wMaxPacketSize);
pxa2xx_udc.c:452:		count = write_packet(ep->reg_uddr, req, max);
pxa2xx_udc.c:458:			if (likely(req->req.length != req->req.actual)
pxa2xx_udc.c:459:					|| req->req.zero)
pxa2xx_udc.c:464:			is_short = unlikely (max < ep->fifo_size);
pxa2xx_udc.c:468:			ep->ep.name, count,
pxa2xx_udc.c:470:			req->req.length - req->req.actual, req);
pxa2xx_udc.c:476:		*ep->reg_udccs = UDCCS_BI_TPC;
pxa2xx_udc.c:478:			*ep->reg_udccs = UDCCS_BI_TSP;
pxa2xx_udc.c:483:			if (list_empty(&ep->queue) || unlikely(ep->dma >= 0)) {
pxa2xx_udc.c:484:				pio_irq_disable (ep->bEndpointAddress);
pxa2xx_udc.c:487:				if (unlikely(!list_empty(&ep->queue))) {
pxa2xx_udc.c:488:					req = list_entry(ep->queue.next,
pxa2xx_udc.c:502:	} while (*ep->reg_udccs & UDCCS_BI_TFS);
pxa2xx_udc.c:506:/* caller asserts req->pending (ep0 irq status nyet cleared); starts
pxa2xx_udc.c:514:	dev->req_pending = 0;
pxa2xx_udc.c:526:	ep->dev->stats.write.bytes += count;
pxa2xx_udc.c:532:		req->req.length - req->req.actual, req);
pxa2xx_udc.c:535:		if (ep->dev->req_pending)
pxa2xx_udc.c:536:			ep0start(ep->dev, UDCCS0_IPR, "short IN");
pxa2xx_udc.c:540:		count = req->req.length;
pxa2xx_udc.c:542:		ep0_idle(ep->dev);
pxa2xx_udc.c:558:				count--;
pxa2xx_udc.c:563:	} else if (ep->dev->req_pending)
pxa2xx_udc.c:564:		ep0start(ep->dev, 0, "IN");
pxa2xx_udc.c:570: * read_fifo -  unload packet(s) from the fifo we use for usb OUT
pxa2xx_udc.c:575: * request buffer having filled (and maybe overran till end-of-packet).
pxa2xx_udc.c:589:		udccs = *ep->reg_udccs;
pxa2xx_udc.c:592:		buf = req->req.buf + req->req.actual;
pxa2xx_udc.c:594:		bufferspace = req->req.length - req->req.actual;
pxa2xx_udc.c:598:			count = 1 + (0x0ff & *ep->reg_ubcr);
pxa2xx_udc.c:599:			req->req.actual += min (count, bufferspace);
pxa2xx_udc.c:602:		is_short = (count < ep->ep.maxpacket);
pxa2xx_udc.c:604:			ep->ep.name, udccs, count,
pxa2xx_udc.c:606:			req, req->req.actual, req->req.length);
pxa2xx_udc.c:607:		while (likely (count-- != 0)) {
pxa2xx_udc.c:608:			u8	byte = (u8) *ep->reg_uddr;
pxa2xx_udc.c:615:				if (req->req.status != -EOVERFLOW)
pxa2xx_udc.c:617:						ep->ep.name, count);
pxa2xx_udc.c:618:				req->req.status = -EOVERFLOW;
pxa2xx_udc.c:621:				bufferspace--;
pxa2xx_udc.c:624:		*ep->reg_udccs =  UDCCS_BO_RPC;
pxa2xx_udc.c:628:		if (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
pxa2xx_udc.c:630:				req->req.status = -EHOSTUNREACH;
pxa2xx_udc.c:636:		if (is_short || req->req.actual == req->req.length) {
pxa2xx_udc.c:638:			if (list_empty(&ep->queue))
pxa2xx_udc.c:639:				pio_irq_disable (ep->bEndpointAddress);
pxa2xx_udc.c:650: * handshaking is magic.  most device protocols don't need control-OUT.
pxa2xx_udc.c:660:	buf = req->req.buf + req->req.actual;
pxa2xx_udc.c:661:	bufferspace = req->req.length - req->req.actual;
pxa2xx_udc.c:671:			if (req->req.status != -EOVERFLOW)
pxa2xx_udc.c:672:				DMSG("%s overflow\n", ep->ep.name);
pxa2xx_udc.c:673:			req->req.status = -EOVERFLOW;
pxa2xx_udc.c:676:			req->req.actual++;
pxa2xx_udc.c:677:			bufferspace--;
pxa2xx_udc.c:684:	if (req->req.actual >= req->req.length)
pxa2xx_udc.c:693:#define	MAX_IN_DMA	((DCMD_LENGTH + 1) - BULK_FIFO_SIZE)
pxa2xx_udc.c:698:	u32	dcmd = req->req.length;
pxa2xx_udc.c:699:	u32	buf = req->req.dma;
pxa2xx_udc.c:700:	u32	fifo = io_v2p ((u32)ep->reg_uddr);
pxa2xx_udc.c:703:	 *  - IN may end with a short packet (TSP set separately),
pxa2xx_udc.c:704:	 *  - OUT is always full length
pxa2xx_udc.c:706:	buf += req->req.actual;
pxa2xx_udc.c:707:	dcmd -= req->req.actual;
pxa2xx_udc.c:708:	ep->dma_fixup = 0;
pxa2xx_udc.c:710:	/* no-descriptor mode can be simple for bulk-in, iso-in, iso-out */
pxa2xx_udc.c:711:	DCSR(ep->dma) = DCSR_NODESC;
pxa2xx_udc.c:713:		DSADR(ep->dma) = buf;
pxa2xx_udc.c:714:		DTADR(ep->dma) = fifo;
pxa2xx_udc.c:718:			ep->dma_fixup = (dcmd % ep->ep.maxpacket) != 0;
pxa2xx_udc.c:723:		DSADR(ep->dma) = fifo;
pxa2xx_udc.c:724:		DTADR(ep->dma) = buf;
pxa2xx_udc.c:725:		if (ep->bmAttributes != USB_ENDPOINT_XFER_ISOC)
pxa2xx_udc.c:726:			dcmd = ep->ep.maxpacket;
pxa2xx_udc.c:731:	DCMD(ep->dma) = dcmd;
pxa2xx_udc.c:732:	DCSR(ep->dma) = DCSR_RUN | DCSR_NODESC
pxa2xx_udc.c:740:	int	is_in = ep->bEndpointAddress & USB_DIR_IN;
pxa2xx_udc.c:744:		if ((req->req.dma & 0x0f) != 0
pxa2xx_udc.c:745:				|| unlikely((req->req.length - req->req.actual)
pxa2xx_udc.c:747:			pio_irq_enable(ep->bEndpointAddress);
pxa2xx_udc.c:748:			if ((*ep->reg_udccs & UDCCS_BI_TFS) != 0)
pxa2xx_udc.c:754:		if ((req->req.length - req->req.actual) < ep->ep.maxpacket) {
pxa2xx_udc.c:755:			DMSG("%s short dma read...\n", ep->ep.name);
pxa2xx_udc.c:759:			*ep->reg_udccs = UDCCS_BO_DME
pxa2xx_udc.c:760:				| (*ep->reg_udccs & UDCCS_BO_FST);
pxa2xx_udc.c:771:	if (DCSR(ep->dma) == 0 || list_empty(&ep->queue))
pxa2xx_udc.c:774:	DCSR(ep->dma) = 0;
pxa2xx_udc.c:775:	while ((DCSR(ep->dma) & DCSR_STOPSTATE) == 0)
pxa2xx_udc.c:778:	req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
pxa2xx_udc.c:779:	tmp = DCMD(ep->dma) & DCMD_LENGTH;
pxa2xx_udc.c:780:	req->req.actual = req->req.length - (tmp & DCMD_LENGTH);
pxa2xx_udc.c:785:	if (ep->bEndpointAddress & USB_DIR_IN)
pxa2xx_udc.c:786:		*ep->reg_udccs = UDCCS_BI_FTF;
pxa2xx_udc.c:798:	req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
pxa2xx_udc.c:800:	ep->dma_irqs++;
pxa2xx_udc.c:801:	ep->dev->stats.irqs++;
pxa2xx_udc.c:802:	HEX_DISPLAY(ep->dev->stats.irqs);
pxa2xx_udc.c:805:	tmp = DCSR(ep->dma);
pxa2xx_udc.c:806:	DCSR(ep->dma) = tmp;
pxa2xx_udc.c:808:			|| (DDADR(ep->dma) & DDADR_STOP) != 0) {
pxa2xx_udc.c:810:			ep->ep.name, DCSR(ep->dma), DDADR(ep->dma));
pxa2xx_udc.c:813:	DCSR(ep->dma) = 0;	/* clear DCSR_STOPSTATE */
pxa2xx_udc.c:817:	if (ep->bEndpointAddress & USB_DIR_IN)
pxa2xx_udc.c:818:		tmp = DSADR(ep->dma);
pxa2xx_udc.c:820:		tmp = DTADR(ep->dma);
pxa2xx_udc.c:821:	req->req.actual = tmp - req->req.dma;
pxa2xx_udc.c:826:		req->req.status = -EIO;
pxa2xx_udc.c:827:	else if (req->req.actual) {
pxa2xx_udc.c:829:		 * some (end-of-transfer) short packets:  tx 14 as tx 12
pxa2xx_udc.c:831:		if (ep->dma_fixup)
pxa2xx_udc.c:832:			req->req.actual = min(req->req.actual + 3,
pxa2xx_udc.c:833:						req->req.length);
pxa2xx_udc.c:835:		tmp = (req->req.length - req->req.actual);
pxa2xx_udc.c:837:		if (completed && (ep->bEndpointAddress & USB_DIR_IN)) {
pxa2xx_udc.c:840:			if ((req->req.actual % ep->ep.maxpacket) != 0)
pxa2xx_udc.c:841:				*ep->reg_udccs = UDCCS_BI_TSP/*|UDCCS_BI_TPC*/;
pxa2xx_udc.c:844:			else if (ep->bmAttributes == USB_ENDPOINT_XFER_BULK
pxa2xx_udc.c:845:					&& req->req.zero) {
pxa2xx_udc.c:846:				DMSG("%s zlp terminate ...\n", ep->ep.name);
pxa2xx_udc.c:855:		/* maybe re-activate after completion */
pxa2xx_udc.c:856:		if (ep->stopped || list_empty(&ep->queue))
pxa2xx_udc.c:858:		req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
pxa2xx_udc.c:867:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:878:	if (unlikely (!_req || !_req->complete || !_req->buf
pxa2xx_udc.c:879:			|| !list_empty(&req->queue))) {
pxa2xx_udc.c:881:		return -EINVAL;
pxa2xx_udc.c:885:	if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
pxa2xx_udc.c:887:		return -EINVAL;
pxa2xx_udc.c:890:	dev = ep->dev;
pxa2xx_udc.c:891:	if (unlikely (!dev->driver
pxa2xx_udc.c:892:			|| dev->gadget.speed == USB_SPEED_UNKNOWN)) {
pxa2xx_udc.c:894:		return -ESHUTDOWN;
pxa2xx_udc.c:898:	 * we can report per-packet status.  that also helps with dma.
pxa2xx_udc.c:900:	if (unlikely (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
pxa2xx_udc.c:901:			&& req->req.length > le16_to_cpu
pxa2xx_udc.c:902:						(ep->desc->wMaxPacketSize)))
pxa2xx_udc.c:903:		return -EMSGSIZE;
pxa2xx_udc.c:907:	if (ep->dma >= 0) {
pxa2xx_udc.c:908:		_req->dma = dma_map_single(dev->dev,
pxa2xx_udc.c:909:			_req->buf, _req->length,
pxa2xx_udc.c:910:			((ep->bEndpointAddress & USB_DIR_IN) != 0)
pxa2xx_udc.c:917:	     _ep->name, _req, _req->length, _req->buf);
pxa2xx_udc.c:921:	_req->status = -EINPROGRESS;
pxa2xx_udc.c:922:	_req->actual = 0;
pxa2xx_udc.c:925:	if (list_empty(&ep->queue) && !ep->stopped) {
pxa2xx_udc.c:926:		if (ep->desc == 0 /* ep0 */) {
pxa2xx_udc.c:927:			unsigned	length = _req->length;
pxa2xx_udc.c:929:			switch (dev->ep0state) {
pxa2xx_udc.c:931:				dev->stats.write.ops++;
pxa2xx_udc.c:937:				dev->stats.read.ops++;
pxa2xx_udc.c:939:				if (dev->req_config) {
pxa2xx_udc.c:941:						dev->has_cfr ?  "" : " raced");
pxa2xx_udc.c:942:					if (dev->has_cfr)
pxa2xx_udc.c:945:					dev->ep0state = EP0_END_XFER;
pxa2xx_udc.c:948:				if (dev->req_pending)
pxa2xx_udc.c:959:				DMSG("ep0 i/o, odd state %d\n", dev->ep0state);
pxa2xx_udc.c:961:				return -EL2HLT;
pxa2xx_udc.c:965:		} else if (ep->dma >= 0) {
pxa2xx_udc.c:969:		} else if ((ep->bEndpointAddress & USB_DIR_IN) != 0
pxa2xx_udc.c:970:				&& (*ep->reg_udccs & UDCCS_BI_TFS) != 0
pxa2xx_udc.c:973:		} else if ((*ep->reg_udccs & UDCCS_BO_RFS) != 0
pxa2xx_udc.c:978:		if (likely (req && ep->desc) && ep->dma < 0)
pxa2xx_udc.c:979:			pio_irq_enable(ep->bEndpointAddress);
pxa2xx_udc.c:984:		list_add_tail(&req->queue, &ep->queue);
pxa2xx_udc.c:992: * 	nuke - dequeue ALL requests
pxa2xx_udc.c:1000:	if (ep->dma >= 0 && !ep->stopped)
pxa2xx_udc.c:1003:	while (!list_empty(&ep->queue)) {
pxa2xx_udc.c:1004:		req = list_entry(ep->queue.next,
pxa2xx_udc.c:1009:	if (ep->desc)
pxa2xx_udc.c:1010:		pio_irq_disable (ep->bEndpointAddress);
pxa2xx_udc.c:1022:	if (!_ep || ep->ep.name == ep0name)
pxa2xx_udc.c:1023:		return -EINVAL;
pxa2xx_udc.c:1028:	list_for_each_entry (req, &ep->queue, queue) {
pxa2xx_udc.c:1029:		if (&req->req == _req)
pxa2xx_udc.c:1032:	if (&req->req != _req) {
pxa2xx_udc.c:1034:		return -EINVAL;
pxa2xx_udc.c:1038:	if (ep->dma >= 0 && ep->queue.next == &req->queue && !ep->stopped) {
pxa2xx_udc.c:1040:		done(ep, req, -ECONNRESET);
pxa2xx_udc.c:1042:		if (!list_empty(&ep->queue)) {
pxa2xx_udc.c:1043:			req = list_entry(ep->queue.next,
pxa2xx_udc.c:1049:		done(ep, req, -ECONNRESET);
pxa2xx_udc.c:1055:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:1064:			|| (!ep->desc && ep->ep.name != ep0name))
pxa2xx_udc.c:1065:			|| ep->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
pxa2xx_udc.c:1067:		return -EINVAL;
pxa2xx_udc.c:1075:		DMSG("only host can clear %s halt\n", _ep->name);
pxa2xx_udc.c:1076:		return -EROFS;
pxa2xx_udc.c:1081:	if ((ep->bEndpointAddress & USB_DIR_IN) != 0
pxa2xx_udc.c:1082:			&& ((*ep->reg_udccs & UDCCS_BI_TFS) == 0
pxa2xx_udc.c:1083:			   || !list_empty(&ep->queue))) {
pxa2xx_udc.c:1085:		return -EAGAIN;
pxa2xx_udc.c:1089:	*ep->reg_udccs = UDCCS_BI_FST|UDCCS_BI_FTF;
pxa2xx_udc.c:1092:	if (!ep->desc) {
pxa2xx_udc.c:1093:		start_watchdog(ep->dev);
pxa2xx_udc.c:1094:		ep->dev->req_pending = 0;
pxa2xx_udc.c:1095:		ep->dev->ep0state = EP0_STALL;
pxa2xx_udc.c:1102: 			if (*ep->reg_udccs & UDCCS_BI_SST)
pxa2xx_udc.c:1109:	DBG(DBG_VERBOSE, "%s halt\n", _ep->name);
pxa2xx_udc.c:1120:		return -ENODEV;
pxa2xx_udc.c:1123:	if ((ep->bEndpointAddress & USB_DIR_IN) != 0)
pxa2xx_udc.c:1124:		return -EOPNOTSUPP;
pxa2xx_udc.c:1125:	if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN
pxa2xx_udc.c:1126:			|| (*ep->reg_udccs & UDCCS_BO_RFS) == 0)
pxa2xx_udc.c:1129:		return (*ep->reg_ubcr & 0xfff) + 1;
pxa2xx_udc.c:1137:	if (!_ep || ep->ep.name == ep0name || !list_empty(&ep->queue)) {
pxa2xx_udc.c:1145:	if ((ep->bEndpointAddress & USB_DIR_IN) == 0) {
pxa2xx_udc.c:1146:		while (((*ep->reg_udccs) & UDCCS_BO_RNE) != 0)
pxa2xx_udc.c:1147:			(void) *ep->reg_uddr;
pxa2xx_udc.c:1152:	*ep->reg_udccs = UDCCS_BI_TPC|UDCCS_BI_FTF|UDCCS_BI_TUR
pxa2xx_udc.c:1153:		| (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC)
pxa2xx_udc.c:1177:/* ---------------------------------------------------------------------------
pxa2xx_udc.c:1178: * 	device-scoped parts of the api to the usb controller hardware
pxa2xx_udc.c:1179: * ---------------------------------------------------------------------------
pxa2xx_udc.c:1191:		return -EHOSTUNREACH;
pxa2xx_udc.c:1199:	// current versions must always be self-powered
pxa2xx_udc.c:1203:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:1230:		dev->driver ? dev->driver->driver.name : "(none)",
pxa2xx_udc.c:1232:	size -= t;
pxa2xx_udc.c:1239:	size -= t;
pxa2xx_udc.c:1253:	size -= t;
pxa2xx_udc.c:1267:	size -= t;
pxa2xx_udc.c:1270:	if (dev->has_cfr) {
pxa2xx_udc.c:1276:		size -= t;
pxa2xx_udc.c:1280:	if (!is_usb_connected() || !dev->driver)
pxa2xx_udc.c:1284:		dev->stats.write.bytes, dev->stats.write.ops,
pxa2xx_udc.c:1285:		dev->stats.read.bytes, dev->stats.read.ops,
pxa2xx_udc.c:1286:		dev->stats.irqs);
pxa2xx_udc.c:1287:	size -= t;
pxa2xx_udc.c:1292:		struct pxa2xx_ep	*ep = &dev->ep [i];
pxa2xx_udc.c:1299:			d = ep->desc;
pxa2xx_udc.c:1302:			tmp = *dev->ep [i].reg_udccs;
pxa2xx_udc.c:1305:				ep->ep.name, le16_to_cpu (d->wMaxPacketSize),
pxa2xx_udc.c:1306:				(ep->dma >= 0) ? "dma" : "pio", tmp,
pxa2xx_udc.c:1307:				ep->pio_irqs, ep->dma_irqs);
pxa2xx_udc.c:1312:				ep->pio_irqs);
pxa2xx_udc.c:1315:		size -= t;
pxa2xx_udc.c:1318:		if (list_empty(&ep->queue)) {
pxa2xx_udc.c:1322:			size -= t;
pxa2xx_udc.c:1326:		list_for_each_entry(req, &ep->queue, queue) {
pxa2xx_udc.c:1328:			if (ep->dma >= 0 && req->queue.prev == &ep->queue)
pxa2xx_udc.c:1332:					&req->req, req->req.actual,
pxa2xx_udc.c:1333:					req->req.length, req->req.buf,
pxa2xx_udc.c:1334:					ep->dma, DCMD(ep->dma)
pxa2xx_udc.c:1335:					// low 13 bits == bytes-to-go
pxa2xx_udc.c:1341:					&req->req, req->req.actual,
pxa2xx_udc.c:1342:					req->req.length, req->req.buf);
pxa2xx_udc.c:1345:			size -= t;
pxa2xx_udc.c:1353:	return count - size;
pxa2xx_udc.c:1374:	if (!dev->driver
pxa2xx_udc.c:1375:			|| !dev->driver->function
pxa2xx_udc.c:1376:			|| strlen (dev->driver->function) > PAGE_SIZE)
pxa2xx_udc.c:1378:	return scnprintf (buf, PAGE_SIZE, "%s\n", dev->driver->function);
pxa2xx_udc.c:1382:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:1385: * 	udc_disable - disable USB device controller
pxa2xx_udc.c:1405:	dev->gadget.speed = USB_SPEED_UNKNOWN;
pxa2xx_udc.c:1411: * 	udc_reinit - initialize software state
pxa2xx_udc.c:1418:	INIT_LIST_HEAD (&dev->gadget.ep_list);
pxa2xx_udc.c:1419:	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
pxa2xx_udc.c:1420:	dev->ep0state = EP0_IDLE;
pxa2xx_udc.c:1424:		struct pxa2xx_ep *ep = &dev->ep[i];
pxa2xx_udc.c:1427:			list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
pxa2xx_udc.c:1429:		ep->desc = 0;
pxa2xx_udc.c:1430:		ep->stopped = 0;
pxa2xx_udc.c:1431:		INIT_LIST_HEAD (&ep->queue);
pxa2xx_udc.c:1432:		ep->pio_irqs = ep->dma_irqs = 0;
pxa2xx_udc.c:1435:	/* the rest was statically initialized, and is read-only */
pxa2xx_udc.c:1454:	dev->gadget.speed = USB_SPEED_UNKNOWN;
pxa2xx_udc.c:1455:	dev->stats.irqs = 0;
pxa2xx_udc.c:1459:	 * - enable UDC
pxa2xx_udc.c:1460:	 * - if RESET is already in progress, ack interrupt
pxa2xx_udc.c:1461:	 * - unmask reset interrupt
pxa2xx_udc.c:1467:	if (dev->has_cfr /* UDC_RES2 is defined */) {
pxa2xx_udc.c:1473:		/* "USB test mode" for pxa250 errata 40-42 (stepping a0, a1)
pxa2xx_udc.c:1518: * non-control requests.  then usb traffic follows until a
pxa2xx_udc.c:1528:			|| driver->speed != USB_SPEED_FULL
pxa2xx_udc.c:1529:			|| !driver->bind
pxa2xx_udc.c:1530:			|| !driver->unbind
pxa2xx_udc.c:1531:			|| !driver->disconnect
pxa2xx_udc.c:1532:			|| !driver->setup)
pxa2xx_udc.c:1533:		return -EINVAL;
pxa2xx_udc.c:1535:		return -ENODEV;
pxa2xx_udc.c:1536:	if (dev->driver)
pxa2xx_udc.c:1537:		return -EBUSY;
pxa2xx_udc.c:1540:	dev->driver = driver;
pxa2xx_udc.c:1541:	dev->gadget.dev.driver = &driver->driver;
pxa2xx_udc.c:1543:	device_add (&dev->gadget.dev);
pxa2xx_udc.c:1544:	retval = driver->bind(&dev->gadget);
pxa2xx_udc.c:1546:		DMSG("bind to driver %s --> error %d\n",
pxa2xx_udc.c:1547:				driver->driver.name, retval);
pxa2xx_udc.c:1548:		device_del (&dev->gadget.dev);
pxa2xx_udc.c:1550:		dev->driver = 0;
pxa2xx_udc.c:1551:		dev->gadget.dev.driver = 0;
pxa2xx_udc.c:1554:	device_create_file(dev->dev, &dev_attr_function);
pxa2xx_udc.c:1560:	DMSG("registered gadget driver '%s'\n", driver->driver.name);
pxa2xx_udc.c:1573:	if (dev->gadget.speed == USB_SPEED_UNKNOWN)
pxa2xx_udc.c:1575:	dev->gadget.speed = USB_SPEED_UNKNOWN;
pxa2xx_udc.c:1579:		struct pxa2xx_ep *ep = &dev->ep[i];
pxa2xx_udc.c:1581:		ep->stopped = 1;
pxa2xx_udc.c:1582:		nuke(ep, -ESHUTDOWN);
pxa2xx_udc.c:1584:	del_timer_sync(&dev->timer);
pxa2xx_udc.c:1589:		driver->disconnect(&dev->gadget);
pxa2xx_udc.c:1591:	/* re-init driver-visible data structures */
pxa2xx_udc.c:1600:		return -ENODEV;
pxa2xx_udc.c:1601:	if (!driver || driver != dev->driver)
pxa2xx_udc.c:1602:		return -EINVAL;
pxa2xx_udc.c:1609:	driver->unbind(&dev->gadget);
pxa2xx_udc.c:1610:	dev->driver = 0;
pxa2xx_udc.c:1612:	device_del (&dev->gadget.dev);
pxa2xx_udc.c:1613:	device_remove_file(dev->dev, &dev_attr_function);
pxa2xx_udc.c:1615:	DMSG("unregistered gadget driver '%s'\n", driver->driver.name);
pxa2xx_udc.c:1622:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:1644:	dev->stats.irqs++;
pxa2xx_udc.c:1645:	HEX_DISPLAY(dev->stats.irqs);
pxa2xx_udc.c:1651:		if (dev->gadget.speed != USB_SPEED_UNKNOWN) {
pxa2xx_udc.c:1653:				dev->driver ? dev->driver->driver.name : 0);
pxa2xx_udc.c:1654:			stop_activity(dev, dev->driver);
pxa2xx_udc.c:1660:	} else if (dev->gadget.speed == USB_SPEED_UNKNOWN) {
pxa2xx_udc.c:1682:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:1692:		nuke(&dev->ep[i], -ECONNABORTED);
pxa2xx_udc.c:1700:	if (dev->ep0state == EP0_STALL
pxa2xx_udc.c:1704:		DBG(DBG_VERBOSE, "ep0 re-stall\n");
pxa2xx_udc.c:1713:	struct pxa2xx_ep	*ep = &dev->ep [0];
pxa2xx_udc.c:1721:	if (list_empty(&ep->queue))
pxa2xx_udc.c:1724:		req = list_entry(ep->queue.next, struct pxa2xx_request, queue);
pxa2xx_udc.c:1728:		nuke(ep, -EPIPE);
pxa2xx_udc.c:1730:		del_timer(&dev->timer);
pxa2xx_udc.c:1734:	/* previous request unfinished?  non-error iff back-to-back ... */
pxa2xx_udc.c:1735:	if ((udccs0 & UDCCS0_SA) != 0 && dev->ep0state != EP0_IDLE) {
pxa2xx_udc.c:1737:		del_timer(&dev->timer);
pxa2xx_udc.c:1741:	switch (dev->ep0state) {
pxa2xx_udc.c:1743:		/* late-breaking status? */
pxa2xx_udc.c:1751:			nuke (ep, -EPROTO);
pxa2xx_udc.c:1776:			dev->req_std = (u.r.bRequestType & USB_TYPE_MASK)
pxa2xx_udc.c:1778:			dev->req_config = 0;
pxa2xx_udc.c:1779:			dev->req_pending = 1;
pxa2xx_udc.c:1788:					dev->req_config = 1;
pxa2xx_udc.c:1800:					 *  - altsetting may only be zero;
pxa2xx_udc.c:1801:					 *  - hw resets all interfaces' eps;
pxa2xx_udc.c:1802:					 *  - ep reset doesn't include halt(?).
pxa2xx_udc.c:1819:				dev->ep0state = EP0_IN_DATA_PHASE;
pxa2xx_udc.c:1821:				dev->ep0state = EP0_OUT_DATA_PHASE;
pxa2xx_udc.c:1823:			i = dev->driver->setup(&dev->gadget, &u.r);
pxa2xx_udc.c:1826:				if (dev->req_config) {
pxa2xx_udc.c:1848:				dev->ep0state = EP0_STALL;
pxa2xx_udc.c:1852:			} else if (dev->req_pending) {
pxa2xx_udc.c:1853:				if (likely(dev->ep0state == EP0_IN_DATA_PHASE
pxa2xx_udc.c:1854:						|| dev->req_std || u.r.wLength))
pxa2xx_udc.c:1871:			nuke(ep, -EPROTO);
pxa2xx_udc.c:1884:			 * - we acked FST
pxa2xx_udc.c:1885:			 * - IPR cleared
pxa2xx_udc.c:1886:			 * - OPR got set, without SA (likely status stage)
pxa2xx_udc.c:1923:		/* ack control-IN status (maybe in-zlp was skipped)
pxa2xx_udc.c:1940:	int			is_in = ep->bEndpointAddress & USB_DIR_IN;
pxa2xx_udc.c:1946:		if (likely (!list_empty(&ep->queue)))
pxa2xx_udc.c:1947:			req = list_entry(ep->queue.next,
pxa2xx_udc.c:1954:		udccs = *ep->reg_udccs;
pxa2xx_udc.c:1957:			if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
pxa2xx_udc.c:1961:				*ep->reg_udccs = tmp;
pxa2xx_udc.c:1966:			if (likely(ep->bmAttributes == USB_ENDPOINT_XFER_BULK))
pxa2xx_udc.c:1972:				*ep->reg_udccs = tmp;
pxa2xx_udc.c:1977:// TODO didn't yet debug out-dma.  this approach assumes
pxa2xx_udc.c:1980:				if (likely(ep->dma >= 0)) {
pxa2xx_udc.c:1982:						*ep->reg_udccs = UDCCS_BO_RPC;
pxa2xx_udc.c:1983:						ep->dma_irqs++;
pxa2xx_udc.c:1990:				pio_irq_disable (ep->bEndpointAddress);
pxa2xx_udc.c:1992:		ep->pio_irqs++;
pxa2xx_udc.c:1997: *	pxa2xx_udc_irq - interrupt handler
pxa2xx_udc.c:2009:	dev->stats.irqs++;
pxa2xx_udc.c:2010:	HEX_DISPLAY(dev->stats.irqs);
pxa2xx_udc.c:2024:				stop_activity(dev, dev->driver);
pxa2xx_udc.c:2025:			else if (dev->gadget.speed != USB_SPEED_UNKNOWN
pxa2xx_udc.c:2026:					&& dev->driver
pxa2xx_udc.c:2027:					&& dev->driver->suspend)
pxa2xx_udc.c:2028:				dev->driver->suspend(&dev->gadget);
pxa2xx_udc.c:2038:			if (dev->gadget.speed != USB_SPEED_UNKNOWN
pxa2xx_udc.c:2039:					&& dev->driver
pxa2xx_udc.c:2040:					&& dev->driver->resume
pxa2xx_udc.c:2042:				dev->driver->resume(&dev->gadget);
pxa2xx_udc.c:2045:		/* ReSeT Interrupt Request - USB reset */
pxa2xx_udc.c:2052:				if (dev->gadget.speed != USB_SPEED_UNKNOWN)
pxa2xx_udc.c:2058:				stop_activity (dev, dev->driver);
pxa2xx_udc.c:2062:				dev->gadget.speed = USB_SPEED_FULL;
pxa2xx_udc.c:2064:				memset(&dev->stats, 0, sizeof dev->stats);
pxa2xx_udc.c:2081:				dev->ep[0].pio_irqs++;
pxa2xx_udc.c:2091:					handle_ep(&dev->ep[i]);
pxa2xx_udc.c:2096:					handle_ep(&dev->ep[i+8]);
pxa2xx_udc.c:2109:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:2113:	DMSG("%s %s\n", __FUNCTION__, dev->bus_id);
pxa2xx_udc.c:2116:/* this uses load-time allocation and initialization (instead of
pxa2xx_udc.c:2117: * doing it at run-time) to save code, eliminate fault paths, and
pxa2xx_udc.c:2146:			.name		= "ep1in-bulk",
pxa2xx_udc.c:2160:			.name		= "ep2out-bulk",
pxa2xx_udc.c:2176:			.name		= "ep3in-iso",
pxa2xx_udc.c:2190:			.name		= "ep4out-iso",
pxa2xx_udc.c:2205:			.name		= "ep5in-int",
pxa2xx_udc.c:2220:			.name		= "ep6in-bulk",
pxa2xx_udc.c:2234:			.name		= "ep7out-bulk",
pxa2xx_udc.c:2249:			.name		= "ep8in-iso",
pxa2xx_udc.c:2263:			.name		= "ep9out-iso",
pxa2xx_udc.c:2278:			.name		= "ep10in-int",
pxa2xx_udc.c:2293:			.name		= "ep11in-bulk",
pxa2xx_udc.c:2307:			.name		= "ep12out-bulk",
pxa2xx_udc.c:2322:			.name		= "ep13in-iso",
pxa2xx_udc.c:2336:			.name		= "ep14out-iso",
pxa2xx_udc.c:2351:			.name		= "ep15in-int",
pxa2xx_udc.c:2398: * 	probe - binds to the platform device
pxa2xx_udc.c:2410:		return -ENODEV;
pxa2xx_udc.c:2413:	/* trigger chiprev-specific logic */
pxa2xx_udc.c:2417:		dev->has_cfr = 1;
pxa2xx_udc.c:2440:		return -ENODEV;
pxa2xx_udc.c:2444:		dev->has_cfr ? "" : " (!cfr)",
pxa2xx_udc.c:2445:		out_dma ? "" : " (broken dma-out)",
pxa2xx_udc.c:2456:		dev->ep[ 2].reg_drcmr = dev->ep[ 4].reg_drcmr = 0;
pxa2xx_udc.c:2457:		dev->ep[ 7].reg_drcmr = dev->ep[ 9].reg_drcmr = 0;
pxa2xx_udc.c:2458:		dev->ep[12].reg_drcmr = dev->ep[14].reg_drcmr = 0;
pxa2xx_udc.c:2462:	/* other non-static parts of init */
pxa2xx_udc.c:2463:	dev->dev = _dev;
pxa2xx_udc.c:2464:	dev->mach = _dev->platform_data;
pxa2xx_udc.c:2466:	init_timer(&dev->timer);
pxa2xx_udc.c:2467:	dev->timer.function = udc_watchdog;
pxa2xx_udc.c:2468:	dev->timer.data = (unsigned long) dev;
pxa2xx_udc.c:2470:	device_initialize(&dev->gadget.dev);
pxa2xx_udc.c:2471:	dev->gadget.dev.parent = _dev;
pxa2xx_udc.c:2472:	dev->gadget.dev.dma_mask = _dev->dma_mask;
pxa2xx_udc.c:2486:		return -EBUSY;
pxa2xx_udc.c:2488:	dev->got_irq = 1;
pxa2xx_udc.c:2501:			return -EBUSY;
pxa2xx_udc.c:2503:		dev->got_disc = 1;
pxa2xx_udc.c:2512:	struct pxa2xx_udc *dev = _dev->driver_data;
pxa2xx_udc.c:2516:	usb_gadget_unregister_driver(dev->driver);
pxa2xx_udc.c:2518:	if (dev->got_irq) {
pxa2xx_udc.c:2520:		dev->got_irq = 0;
pxa2xx_udc.c:2522:	if (machine_is_lubbock() && dev->got_disc) {
pxa2xx_udc.c:2524:		dev->got_disc = 0;
pxa2xx_udc.c:2531:/*-------------------------------------------------------------------------*/
pxa2xx_udc.c:2534:	.name		= "pxa2xx-udc",
pxa2xx_udc.c:2541:	// .resume = ... re-enable UDC
rndis.c:16: * 03/12/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
rndis.c:19: * 03/25/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
rndis.c:93:	int 			retval = -ENOTSUPP;
rndis.c:99:	if (!r) return -ENOMEM;
rndis.c:100:	resp = (rndis_query_cmplt_type *) r->buf;
rndis.c:102:	if (!resp) return -ENOMEM;
rndis.c:106:	/* general oids (table 4-1) */
rndis.c:158:				rndis_per_dev_params [configNr].dev->mtu);
rndis.c:185:				rndis_per_dev_params [configNr].dev->mtu);
rndis.c:196:				rndis_per_dev_params [configNr].dev->mtu);
rndis.c:263:	 * of MS-Windows expect OIDs that aren't specified there.  Other
rndis.c:275:	/* statistics OIDs (table 4-2) */
rndis.c:283:			    rndis_per_dev_params [configNr].stats->tx_packets - 
rndis.c:284:			    rndis_per_dev_params [configNr].stats->tx_errors -
rndis.c:285:			    rndis_per_dev_params [configNr].stats->tx_dropped);
rndis.c:299:			    rndis_per_dev_params [configNr].stats->rx_packets - 
rndis.c:300:			    rndis_per_dev_params [configNr].stats->rx_errors -
rndis.c:301:			    rndis_per_dev_params [configNr].stats->rx_dropped);
rndis.c:316:					.stats->tx_errors);
rndis.c:330:					.stats->rx_errors);
rndis.c:344:					.stats->rx_dropped);
rndis.c:364:					.stats->tx_packets - 
rndis.c:366:					 .stats->tx_errors -
rndis.c:368:					 .stats->tx_dropped)
rndis.c:384:					.stats->tx_packets - 
rndis.c:386:					 .stats->tx_errors -
rndis.c:388:					 .stats->tx_dropped)
rndis.c:402:					.stats->multicast*1234);
rndis.c:415:					.stats->multicast);
rndis.c:428:					.stats->tx_packets/42*255);
rndis.c:441:					.stats->tx_packets/42);
rndis.c:466:					.stats->multicast * 1111);
rndis.c:479:					.stats->multicast);
rndis.c:492:					.stats->rx_packets/42*255);
rndis.c:505:					.stats->rx_packets/42);
rndis.c:518:					.stats->rx_crc_errors);
rndis.c:533:	/* ieee802.3 OIDs (table 4-3) */
rndis.c:584:	/* ieee802.3 statistics OIDs (table 4-4) */
rndis.c:594:					.stats->rx_frame_errors);
rndis.c:653:	/* power management OIDs (table 4-5) */
rndis.c:665:			caps->Flags = NDIS_DEVICE_WAKE_UP_ENABLE;
rndis.c:666:			caps->WakeUpCapabilities.MinLinkChangeWakeUp 
rndis.c:687:	resp->InformationBufferOffset = __constant_cpu_to_le32 (16);
rndis.c:688:	resp->InformationBufferLength = cpu_to_le32 (length);
rndis.c:689:	resp->MessageLength = cpu_to_le32 (24 + length);
rndis.c:690:	r->length = 24 + length;
rndis.c:698:	int 				i, retval = -ENOTSUPP;
rndis.c:702:		return -ENOMEM;
rndis.c:703:	resp = (rndis_set_cmplt_type *) r->buf;
rndis.c:705:		return -ENOMEM;
rndis.c:737:		params->filter = cpu_to_le32p((u32 *)buf);
rndis.c:739:			__FUNCTION__, params->filter);
rndis.c:745:		if (params->filter) {
rndis.c:746:			params->state = RNDIS_DATA_INITIALIZED;
rndis.c:747:			netif_carrier_on(params->dev);
rndis.c:748:			if (netif_running(params->dev))
rndis.c:749:				netif_wake_queue (params->dev);
rndis.c:751:			params->state = RNDIS_INITIALIZED;
rndis.c:752:			netif_carrier_off (params->dev);
rndis.c:753:			netif_stop_queue (params->dev);
rndis.c:769:			min(cpu_to_le32(param->ParameterNameLength),80),
rndis.c:770:			buf + param->ParameterNameOffset);
rndis.c:784:		/* always-connected ... */
rndis.c:810:	if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
rndis.c:814:	if (!r) return -ENOMEM;
rndis.c:816:	resp = (rndis_init_cmplt_type *) r->buf;
rndis.c:818:	if (!resp) return -ENOMEM;
rndis.c:820:	resp->MessageType = __constant_cpu_to_le32 (
rndis.c:822:	resp->MessageLength = __constant_cpu_to_le32 (52);
rndis.c:823:	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
rndis.c:824:	resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
rndis.c:825:	resp->MajorVersion = __constant_cpu_to_le32 (RNDIS_MAJOR_VERSION);
rndis.c:826:	resp->MinorVersion = __constant_cpu_to_le32 (RNDIS_MINOR_VERSION);
rndis.c:827:	resp->DeviceFlags = __constant_cpu_to_le32 (RNDIS_DF_CONNECTIONLESS);
rndis.c:828:	resp->Medium = __constant_cpu_to_le32 (RNDIS_MEDIUM_802_3);
rndis.c:829:	resp->MaxPacketsPerTransfer = __constant_cpu_to_le32 (1);
rndis.c:830:	resp->MaxTransferSize = cpu_to_le32 (
rndis.c:831:		  rndis_per_dev_params [configNr].dev->mtu
rndis.c:835:	resp->PacketAlignmentFactor = __constant_cpu_to_le32 (0);
rndis.c:836:	resp->AFListOffset = __constant_cpu_to_le32 (0);
rndis.c:837:	resp->AFListSize = __constant_cpu_to_le32 (0);
rndis.c:851:	// DEBUG("%s: OID = %08X\n", __FUNCTION__, cpu_to_le32(buf->OID));
rndis.c:852:	if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
rndis.c:860:	if (!r) return -ENOMEM;
rndis.c:861:	resp = (rndis_query_cmplt_type *) r->buf;
rndis.c:863:	if (!resp) return -ENOMEM;
rndis.c:865:	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_QUERY_CMPLT);
rndis.c:866:	resp->MessageLength = __constant_cpu_to_le32 (24);
rndis.c:867:	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
rndis.c:869:	if (gen_ndis_query_resp (configNr, cpu_to_le32 (buf->OID), r)) {
rndis.c:871:		resp->Status = __constant_cpu_to_le32 (
rndis.c:873:		resp->InformationBufferLength = __constant_cpu_to_le32 (0);
rndis.c:874:		resp->InformationBufferOffset = __constant_cpu_to_le32 (0);
rndis.c:876:		resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
rndis.c:892:	if (!r) return -ENOMEM;
rndis.c:893:	resp = (rndis_set_cmplt_type *) r->buf;
rndis.c:894:	if (!resp) return -ENOMEM;
rndis.c:896:	BufLength = cpu_to_le32 (buf->InformationBufferLength);
rndis.c:897:	BufOffset = cpu_to_le32 (buf->InformationBufferOffset);
rndis.c:911:	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_SET_CMPLT);
rndis.c:912:	resp->MessageLength = __constant_cpu_to_le32 (16);
rndis.c:913:	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
rndis.c:914:	if (gen_ndis_set_resp (configNr, cpu_to_le32 (buf->OID), 
rndis.c:916:	    resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_NOT_SUPPORTED);
rndis.c:917:	else resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
rndis.c:933:	if (!r) return -ENOMEM;
rndis.c:934:	resp = (rndis_reset_cmplt_type *) r->buf;
rndis.c:935:	if (!resp) return -ENOMEM;
rndis.c:937:	resp->MessageType = __constant_cpu_to_le32 (REMOTE_NDIS_RESET_CMPLT);
rndis.c:938:	resp->MessageLength = __constant_cpu_to_le32 (16);
rndis.c:939:	resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
rndis.c:941:	resp->AddressingReset = __constant_cpu_to_le32 (1);
rndis.c:959:	resp = (rndis_keepalive_cmplt_type *) r->buf;
rndis.c:960:	if (!resp) return -ENOMEM;
rndis.c:962:	resp->MessageType = __constant_cpu_to_le32 (
rndis.c:964:	resp->MessageLength = __constant_cpu_to_le32 (16);
rndis.c:965:	resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
rndis.c:966:	resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
rndis.c:985:	    return -ENOTSUPP;
rndis.c:989:	if (!r) return -ENOMEM;
rndis.c:991:	resp = (rndis_indicate_status_msg_type *) r->buf;
rndis.c:992:	if (!resp) return -ENOMEM;
rndis.c:994:	resp->MessageType = __constant_cpu_to_le32 (
rndis.c:996:	resp->MessageLength = __constant_cpu_to_le32 (20);
rndis.c:997:	resp->Status = cpu_to_le32 (status);
rndis.c:998:	resp->StatusBufferLength = __constant_cpu_to_le32 (0);
rndis.c:999:	resp->StatusBufferOffset = __constant_cpu_to_le32 (0);
rndis.c:1037:		return -ENOMEM;
rndis.c:1044:		return -ENOTSUPP;
rndis.c:1053:		params->state = RNDIS_INITIALIZED;
rndis.c:1060:		params->state = RNDIS_UNINITIALIZED;
rndis.c:1061:		if (params->dev) {
rndis.c:1062:			netif_carrier_off (params->dev);
rndis.c:1063:			netif_stop_queue (params->dev);
rndis.c:1122:	return -ENOTSUPP;
rndis.c:1139:	return -1;
rndis.c:1156:	if (!dev || !stats) return -1;
rndis.c:1157:	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
rndis.c:1168:	if (!vendorDescr) return -1;
rndis.c:1169:	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
rndis.c:1180:	if (configNr >= RNDIS_MAX_CONFIGS) return -1;
rndis.c:1192:	memset (skb->data, 0, sizeof (struct rndis_packet_msg_type));
rndis.c:1193:	*((u32 *) skb->data) = __constant_cpu_to_le32 (1);
rndis.c:1194:	*((u32 *) skb->data + 1) = cpu_to_le32(skb->len);
rndis.c:1195:	*((u32 *) skb->data + 2) = __constant_cpu_to_le32 (36);
rndis.c:1196:	*((u32 *) skb->data + 3) = cpu_to_le32(skb->len - 44);
rndis.c:1210:		if (r && r->buf == buf) {
rndis.c:1211:			list_del (&r->list);
rndis.c:1228:		if (!r->send) {
rndis.c:1229:			r->send = 1;
rndis.c:1230:			*length = r->length;
rndis.c:1231:			return r->buf;
rndis.c:1245:	r->buf = (u8 *) (r + 1);
rndis.c:1246:	r->length = length;
rndis.c:1247:	r->send = 0;
rndis.c:1249:	list_add_tail (&r->list, 
rndis.c:1260:	if (!buf || !length) return -1;
rndis.c:1261:	if (cpu_to_le32p(tmp++) != 1) return -1;
rndis.c:1266:	if (messageLen < dataOffset || messageLen > *length) return -1;
rndis.c:1269:		buf [i - dataOffset] = buf [i];
rndis.c:1271:	*length = messageLen - dataOffset;
rndis.c:1294:			 param->confignr, (param->used) ? "y" : "n", 
rndis.c:1296:			 switch (param->state) {
rndis.c:1304:			 param->medium, 
rndis.c:1305:			 (param->media_state) ? 0 : param->speed*100, 
rndis.c:1306:			 (param->media_state) ? "disconnected" : "connected",
rndis.c:1307:			 param->vendorID, param->vendorDescr);      
rndis.c:1309:	len = out - page;
rndis.c:1310:	len -= off;
rndis.c:1333:			return -EFAULT;
rndis.c:1346:			speed = speed*10 + c - '0';
rndis.c:1350:			rndis_signal_connect (p->confignr);
rndis.c:1354:			rndis_signal_disconnect(p->confignr);
rndis.c:1357:			if (fl_speed) p->speed = speed;
rndis.c:1368:#define	NAME_TEMPLATE	"driver/rndis-%03d"
rndis.c:1389:				sprintf (name, NAME_TEMPLATE, --i);
rndis.c:1393:			return -EIO;
rndis.c:1396:		rndis_connect_state [i]->nlink = 1;
rndis.c:1397:		rndis_connect_state [i]->write_proc = rndis_proc_write;
rndis.c:1398:		rndis_connect_state [i]->read_proc = rndis_proc_read;
rndis.c:1399:		rndis_connect_state [i]->data = (void *)
s3c2410_udc.c:3: * Samsung on-chip full speed USB device controllers
s3c2410_udc.c:5: * Copyright (C) 2004 Herbert Pötzl - Arnaud Patard
s3c2410_udc.c:19: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
s3c2410_udc.c:48:#include <asm/arch/regs-clock.h>
s3c2410_udc.c:49:#include <asm/arch/regs-gpio.h>
s3c2410_udc.c:50:#include <asm/arch/regs-udc.h>
s3c2410_udc.c:60:#define DRIVER_AUTHOR	"Herbert Pötzl <herbert@13thfloor.at>, Arnaud Patard <arnaud.patard@rtp-net.org>"
s3c2410_udc.c:99:			sizeof(printk_buf)-len, fmt, args);
s3c2410_udc.c:164:/*------------------------- I/O ----------------------------------*/
s3c2410_udc.c:168:	if (&ep->queue != NULL)
s3c2410_udc.c:169:		while (!list_empty (&ep->queue)) {
s3c2410_udc.c:171:			req = list_entry (ep->queue.next, struct s3c2410_request, queue);
s3c2410_udc.c:172:			list_del_init (&req->queue);
s3c2410_udc.c:173:			req->req.status = -ESHUTDOWN;
s3c2410_udc.c:174:			spin_unlock (&udc->lock);
s3c2410_udc.c:175:			req->req.complete (&ep->ep, &req->req);
s3c2410_udc.c:176:			spin_lock (&udc->lock);
s3c2410_udc.c:185:	list_del_init(&req->queue);
s3c2410_udc.c:187:	if (likely (req->req.status == -EINPROGRESS))
s3c2410_udc.c:188:		req->req.status = status;
s3c2410_udc.c:190:		status = req->req.status;
s3c2410_udc.c:192:	req->req.complete(&ep->ep, &req->req);
s3c2410_udc.c:203:			 nuke(dev, &dev->ep[i]);
s3c2410_udc.c:225:	buf = req->req.buf + req->req.actual;
s3c2410_udc.c:226:	len = min(req->req.length - req->req.actual, max);
s3c2410_udc.c:227:	dprintk(DEBUG_VERBOSE, "write_packet %d %d %d ",req->req.actual,req->req.length,len);
s3c2410_udc.c:228:	req->req.actual += len;
s3c2410_udc.c:229:	dprintk(DEBUG_VERBOSE, "%d\n",req->req.actual);
s3c2410_udc.c:232:	while (max--)
s3c2410_udc.c:250:	switch(ep->bEndpointAddress&0x7F)
s3c2410_udc.c:277:	buf = req->req.buf + req->req.actual;
s3c2410_udc.c:280:	count = ep->ep.maxpacket;
s3c2410_udc.c:284:	if (count < ep->ep.maxpacket)
s3c2410_udc.c:286:	else if (req->req.length == req->req.actual
s3c2410_udc.c:287:			&& !req->req.zero)
s3c2410_udc.c:292:	dprintk(DEBUG_VERBOSE, "Written ep%d %d. %d of %d b [last %d]\n",idx,count,req->req.actual,req->req.length,is_last);
s3c2410_udc.c:301:			ep->dev->ep0state=EP0_IDLE;
s3c2410_udc.c:334:	len = min(req->req.length - req->req.actual, avail);
s3c2410_udc.c:335:	req->req.actual += len;
s3c2410_udc.c:338:	while (avail--)
s3c2410_udc.c:355:	switch(ep->bEndpointAddress&0x7F)
s3c2410_udc.c:383:	buf = req->req.buf + req->req.actual;
s3c2410_udc.c:384:	bufferspace = req->req.length - req->req.actual;
s3c2410_udc.c:388:		return -1;
s3c2410_udc.c:397:	if (fifo_count > ep->ep.maxpacket)
s3c2410_udc.c:398:		avail = ep->ep.maxpacket;
s3c2410_udc.c:404:	if (fifo_count < ep->ep.maxpacket) {
s3c2410_udc.c:408:			req->req.status = -EOVERFLOW;
s3c2410_udc.c:411:		if (req->req.length == req->req.actual) 
s3c2410_udc.c:426:			ep->dev->ep0state=EP0_IDLE;
s3c2410_udc.c:436:		if (!list_empty(&ep->queue))
s3c2410_udc.c:439:			req = container_of(ep->queue.next,
s3c2410_udc.c:485:	while( fifo_count-- ) {
s3c2410_udc.c:503:			bytes_read, crq->bRequest, crq->bRequestType,
s3c2410_udc.c:504:			crq->wValue, crq->wIndex, crq->wLength);
s3c2410_udc.c:509:/*------------------------- usb state machine -------------------------------*/
s3c2410_udc.c:513:	struct s3c2410_ep	*ep = &dev->ep [0];
s3c2410_udc.c:517:	if (list_empty(&ep->queue))
s3c2410_udc.c:520:		req = list_entry(ep->queue.next, struct s3c2410_request, queue);
s3c2410_udc.c:535:		dev->ep0state = EP0_IDLE;
s3c2410_udc.c:541:	    	/* && dev->ep0state != EP0_IDLE */) {
s3c2410_udc.c:545:		dev->ep0state = EP0_IDLE;
s3c2410_udc.c:550:	switch (dev->ep0state) {
s3c2410_udc.c:569:			dev->req_std = (crq.bRequestType & USB_TYPE_MASK)
s3c2410_udc.c:571:			dev->req_config = 0;
s3c2410_udc.c:572:			dev->req_pending = 1;
s3c2410_udc.c:579:						dev->req_config = 1;
s3c2410_udc.c:597:						dev->address = tmp;
s3c2410_udc.c:609:				dev->ep0state = EP0_IN_DATA_PHASE;
s3c2410_udc.c:611:				dev->ep0state = EP0_OUT_DATA_PHASE;
s3c2410_udc.c:612:			ret = dev->driver->setup(&dev->gadget, &crq);
s3c2410_udc.c:614:				if (dev->req_config) {
s3c2410_udc.c:619:				if (ret == -EOPNOTSUPP)
s3c2410_udc.c:622:					dprintk(DEBUG_NORMAL, "dev->driver->setup failed. (%d)\n",ret);
s3c2410_udc.c:623:				dev->ep0state = EP0_STALL;
s3c2410_udc.c:625:			} else if (dev->req_pending) {
s3c2410_udc.c:626:			    	dprintk(DEBUG_NORMAL, "dev->req_pending... what now?\n");
s3c2410_udc.c:627:				dev->req_pending=0;
s3c2410_udc.c:629:			dprintk(DEBUG_VERBOSE, "ep0state %s\n",ep0states[dev->ep0state]);
s3c2410_udc.c:647:		dev->ep0state=EP0_IDLE;
s3c2410_udc.c:655: * 	handle_ep - Manage I/O endpoints
s3c2410_udc.c:660:	int			is_in = ep->bEndpointAddress & USB_DIR_IN;
s3c2410_udc.c:664:	if (likely (!list_empty(&ep->queue)))
s3c2410_udc.c:665:		req = list_entry(ep->queue.next,
s3c2410_udc.c:670:	idx = (u32)(ep->bEndpointAddress&0x7F);
s3c2410_udc.c:708:#include <asm/arch/regs-irq.h>
s3c2410_udc.c:710: *      s3c2410_udc_irq - interrupt handler
s3c2410_udc.c:724:	spin_lock(&dev->lock);
s3c2410_udc.c:741:	 * - Reset, Resume, Suspend coming -> usb_int_reg
s3c2410_udc.c:742:	 * - EP -> ep_int_reg
s3c2410_udc.c:756:		dev->address = 0x00;
s3c2410_udc.c:759:		dev->gadget.speed = USB_SPEED_FULL;
s3c2410_udc.c:760:		dev->ep0state = EP0_IDLE;
s3c2410_udc.c:772:		if (dev->gadget.speed != USB_SPEED_UNKNOWN
s3c2410_udc.c:773:			&& dev->driver
s3c2410_udc.c:774:			&& dev->driver->resume)
s3c2410_udc.c:775:			dev->driver->resume(&dev->gadget);
s3c2410_udc.c:787:		if (dev->gadget.speed != USB_SPEED_UNKNOWN
s3c2410_udc.c:788:				&& dev->driver
s3c2410_udc.c:789:				&& dev->driver->suspend)
s3c2410_udc.c:790:			dev->driver->suspend(&dev->gadget);
s3c2410_udc.c:792:		dev->ep0state = EP0_IDLE;
s3c2410_udc.c:815:			handle_ep(&dev->ep[i]);
s3c2410_udc.c:825:	spin_unlock(&dev->lock);
s3c2410_udc.c:829:/*------------------------- s3c2410_ep_ops ----------------------------------*/
s3c2410_udc.c:846:	if (!_ep || !desc || ep->desc || _ep->name == ep0name
s3c2410_udc.c:847:			|| desc->bDescriptorType != USB_DT_ENDPOINT)
s3c2410_udc.c:848:		return -EINVAL;
s3c2410_udc.c:849:	dev = ep->dev;
s3c2410_udc.c:850:	if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)
s3c2410_udc.c:851:		return -ENXIO;
s3c2410_udc.c:853:	max = le16_to_cpu (desc->wMaxPacketSize) & 0x1fff;
s3c2410_udc.c:855:	spin_lock_irqsave (&dev->lock, flags);
s3c2410_udc.c:856:	_ep->maxpacket = max & 0x7ff;
s3c2410_udc.c:857:	ep->desc = desc;
s3c2410_udc.c:858:	ep->bEndpointAddress = desc->bEndpointAddress;
s3c2410_udc.c:861:	__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:866:	if (desc->bEndpointAddress & USB_DIR_IN)
s3c2410_udc.c:871:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:873:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:883:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:885:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:891:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:893:		__raw_writel(ep->num, S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:900:	__raw_writel(int_en_reg | (1<<ep->num),S3C2410_UDC_EP_INT_EN_REG);
s3c2410_udc.c:904:	tmp = desc->bEndpointAddress;
s3c2410_udc.c:905:	dprintk (DEBUG_NORMAL, "enable %s(%d) ep%x%s-blk max %02x\n",
s3c2410_udc.c:906:		_ep->name,ep->num, tmp, desc->bEndpointAddress & USB_DIR_IN ? "in" : "out", max);
s3c2410_udc.c:908:	spin_unlock_irqrestore (&dev->lock, flags);
s3c2410_udc.c:923:	if (!_ep || !ep->desc) {
s3c2410_udc.c:925:			_ep ? ep->ep.name : NULL);
s3c2410_udc.c:926:		return -EINVAL;
s3c2410_udc.c:929:	spin_lock_irqsave(&ep->dev->lock, flags);
s3c2410_udc.c:930:	ep->desc = 0;
s3c2410_udc.c:932:	nuke (ep->dev, ep);
s3c2410_udc.c:936:	__raw_writel(int_en_reg & ~(1<<ep->num),S3C2410_UDC_EP_INT_EN_REG);
s3c2410_udc.c:938:	spin_unlock_irqrestore(&ep->dev->lock, flags);
s3c2410_udc.c:940:	dprintk(DEBUG_NORMAL, "%s disabled\n", _ep->name);
s3c2410_udc.c:964:	INIT_LIST_HEAD (&req->queue);
s3c2410_udc.c:965:	return &req->req;
s3c2410_udc.c:980:	if (!ep || !_req || (!ep->desc && _ep->name != ep0name))
s3c2410_udc.c:984:	WARN_ON (!list_empty (&req->queue));
s3c2410_udc.c:1002:	if (!the_controller->driver)
s3c2410_udc.c:1038:	if (unlikely (!_req || !_req->complete || !_req->buf
s3c2410_udc.c:1039:	|| !list_empty(&req->queue))) {
s3c2410_udc.c:1044:			dprintk(DEBUG_NORMAL, "s3c2410_queue: 0 %01d %01d %01d\n",!_req->complete,!_req->buf, !list_empty(&req->queue));
s3c2410_udc.c:1046:		return -EINVAL;
s3c2410_udc.c:1050:	if (unlikely (!_ep || (!ep->desc && ep->ep.name != ep0name))) {
s3c2410_udc.c:1052:		return -EINVAL;
s3c2410_udc.c:1055:	dev = ep->dev;
s3c2410_udc.c:1056:	if (unlikely (!dev->driver
s3c2410_udc.c:1057:			|| dev->gadget.speed == USB_SPEED_UNKNOWN)) {
s3c2410_udc.c:1058:		return -ENXIO;
s3c2410_udc.c:1062:	 * we can report per-packet status.  that also helps with dma.
s3c2410_udc.c:1064:	if (unlikely (ep->bmAttributes == USB_ENDPOINT_XFER_ISOC
s3c2410_udc.c:1065:			&& req->req.length > le16_to_cpu
s3c2410_udc.c:1066:						(ep->desc->wMaxPacketSize)))
s3c2410_udc.c:1067:		return -EMSGSIZE;
s3c2410_udc.c:1069:	_req->status = -EINPROGRESS;
s3c2410_udc.c:1070:	_req->actual = 0;
s3c2410_udc.c:1072:	if (ep->bEndpointAddress)
s3c2410_udc.c:1074:		__raw_writel(ep->bEndpointAddress&0x7F,S3C2410_UDC_INDEX_REG);
s3c2410_udc.c:1075:		ep_csr = __raw_readl(ep->bEndpointAddress&USB_DIR_IN ? S3C2410_UDC_IN_CSR1_REG : S3C2410_UDC_OUT_CSR1_REG);
s3c2410_udc.c:1079:	if (list_empty(&ep->queue)) {
s3c2410_udc.c:1080:		if (ep->bEndpointAddress == 0 /* ep0 */) {
s3c2410_udc.c:1082:			switch (dev->ep0state) {
s3c2410_udc.c:1092:				dev->ep0state = EP0_IDLE;
s3c2410_udc.c:1096:				return -EL2HLT;
s3c2410_udc.c:1099:		else if ((ep->bEndpointAddress & USB_DIR_IN) != 0
s3c2410_udc.c:1110:		list_add_tail(&req->queue, &ep->queue);
s3c2410_udc.c:1122:	int			retval = -EINVAL;
s3c2410_udc.c:1128:	if (!the_controller->driver)
s3c2410_udc.c:1129:		return -ENXIO;
s3c2410_udc.c:1134:	udc = container_of (ep->gadget, struct s3c2410_udc, gadget);
s3c2410_udc.c:1136:	spin_lock_irqsave (&udc->lock, flags);
s3c2410_udc.c:1137:	list_for_each_entry (req, &ep->queue, queue) {
s3c2410_udc.c:1138:		if (&req->req == _req) {
s3c2410_udc.c:1139:			list_del_init (&req->queue);
s3c2410_udc.c:1140:			_req->status = -ECONNRESET;
s3c2410_udc.c:1145:	spin_unlock_irqrestore (&udc->lock, flags);
s3c2410_udc.c:1149:				req, _ep->name, _req->length, _req->buf);
s3c2410_udc.c:1151:		_req->complete (_ep, _req);
s3c2410_udc.c:1152:		done(ep, req, -ECONNRESET);
s3c2410_udc.c:1186:/*------------------------- usb_gadget_ops ----------------------------------*/
s3c2410_udc.c:1226:		udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED);
s3c2410_udc.c:1228:		udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED);
s3c2410_udc.c:1242:/*------------------------- gadget driver handling---------------------------*/
s3c2410_udc.c:1251:	if (udc_info && udc_info->udc_command)
s3c2410_udc.c:1252:		udc_info->udc_command(S3C2410_UDC_P_DISABLE);
s3c2410_udc.c:1262:	dev->gadget.speed = USB_SPEED_UNKNOWN;
s3c2410_udc.c:1272:	INIT_LIST_HEAD (&dev->gadget.ep_list);
s3c2410_udc.c:1273:	INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
s3c2410_udc.c:1274:	dev->ep0state = EP0_IDLE;
s3c2410_udc.c:1278:		struct s3c2410_ep *ep = &dev->ep[i];
s3c2410_udc.c:1281:			list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
s3c2410_udc.c:1283:		ep->dev = dev;
s3c2410_udc.c:1284:		ep->desc = 0;
s3c2410_udc.c:1285:		INIT_LIST_HEAD (&ep->queue);
s3c2410_udc.c:1298:	dev->gadget.speed = USB_SPEED_UNKNOWN;
s3c2410_udc.c:1317:	if (udc_info && udc_info->udc_command)
s3c2410_udc.c:1318:		udc_info->udc_command(S3C2410_UDC_P_ENABLE);
s3c2410_udc.c:1327:	        dprintk(DEBUG_NORMAL, "%s %s\n", __FUNCTION__, dev->bus_id);
s3c2410_udc.c:1339:		driver->driver.name);
s3c2410_udc.c:1343:		return -ENODEV;
s3c2410_udc.c:1344:	if (udc->driver)
s3c2410_udc.c:1345:		return -EBUSY;
s3c2410_udc.c:1346:	if (!driver->bind || !driver->unbind || !driver->setup
s3c2410_udc.c:1347:			|| driver->speed == USB_SPEED_UNKNOWN)
s3c2410_udc.c:1348:		return -EINVAL;
s3c2410_udc.c:1351:	udc->driver = driver;
s3c2410_udc.c:1352:	udc->gadget.dev.driver = &driver->driver;
s3c2410_udc.c:1355:	device_add(&udc->gadget.dev);
s3c2410_udc.c:1356:	dprintk(DEBUG_NORMAL, "binding gadget driver '%s'\n", driver->driver.name);
s3c2410_udc.c:1357:	if ((retval = driver->bind (&udc->gadget)) != 0) {
s3c2410_udc.c:1358:		device_del(&udc->gadget.dev);
s3c2410_udc.c:1359:		udc->driver = 0;
s3c2410_udc.c:1360:		udc->gadget.dev.driver = 0;
s3c2410_udc.c:1364:        /* driver->driver.bus = 0; */
s3c2410_udc.c:1382:		return -ENODEV;
s3c2410_udc.c:1383:	if (!driver || driver != udc->driver)
s3c2410_udc.c:1384:		return -EINVAL;
s3c2410_udc.c:1387:		driver->driver.name);
s3c2410_udc.c:1389:	driver->unbind (&udc->gadget);
s3c2410_udc.c:1390:	device_del(&udc->gadget.dev);
s3c2410_udc.c:1391:	udc->driver = 0;
s3c2410_udc.c:1393:	device_release_driver (&udc->gadget.dev);
s3c2410_udc.c:1394:	driver_unregister (&driver->driver);
s3c2410_udc.c:1402:/*---------------------------------------------------------------------------*/
s3c2410_udc.c:1429:			.name		= "ep1-bulk",
s3c2410_udc.c:1441:			.name		= "ep2-bulk",
s3c2410_udc.c:1453:			.name		= "ep3-bulk",
s3c2410_udc.c:1465:			.name		= "ep4-bulk",
s3c2410_udc.c:1478: *	probe - binds to the platform device
s3c2410_udc.c:1488:	spin_lock_init (&udc->lock);
s3c2410_udc.c:1489:	udc_info = _dev->platform_data;
s3c2410_udc.c:1491:	device_initialize(&udc->gadget.dev);
s3c2410_udc.c:1492:	udc->gadget.dev.parent = _dev;
s3c2410_udc.c:1493:	udc->gadget.dev.dma_mask = _dev->dma_mask;
s3c2410_udc.c:1507:		return -EBUSY;
s3c2410_udc.c:1523:	struct s3c2410_udc *udc = _dev->driver_data;
s3c2410_udc.c:1526:	usb_gadget_unregister_driver(udc->driver);
s3c2410_udc.c:1528:	if (udc->got_irq) {
s3c2410_udc.c:1530:		udc->got_irq = 0;
s3c2410_udc.c:1540:	.name		= "s3c2410-usbgadget",
s3c2410_udc.c:1552:	udc_clock = clk_get(NULL, "usb-device");
s3c2410_udc.c:1555:		return -ENOENT;
serial.c:2: * g_serial.c -- USB gadget serial driver
serial.c:10: * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
serial.c:71:		ret = -ERESTARTSYS;					\
serial.c:74:	current->state = TASK_RUNNING;					\
serial.c:107:		ret = -ERESTARTSYS;					\
serial.c:110:	current->state = TASK_RUNNING;					\
serial.c:125:/* CDC-ACM Defines and Structures */
serial.c:266: * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
serial.c:267: * Instead:  allocate your own, using normal USB-IF procedures.
serial.c:270:#define GS_PRODUCT_ID			0xa4a6	/* Linux-USB Serial Gadget */
serial.c:271:#define GS_CDC_PRODUCT_ID		0xa4a7	/* ... as CDC-ACM */
serial.c:467:/* static strings, in UTF-8 */
serial.c:481:	.language =		0x0409,	/* en-us */
serial.c:739:		return -ENOMEM;
serial.c:740:	gs_tty_driver->owner = THIS_MODULE;
serial.c:741:	gs_tty_driver->driver_name = GS_SHORT_NAME;
serial.c:742:	gs_tty_driver->name = "ttygs";
serial.c:743:	gs_tty_driver->devfs_name = "usb/ttygs/";
serial.c:744:	gs_tty_driver->major = GS_MAJOR;
serial.c:745:	gs_tty_driver->minor_start = GS_MINOR_START;
serial.c:746:	gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
serial.c:747:	gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
serial.c:748:	gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
serial.c:749:	gs_tty_driver->init_termios = tty_std_termios;
serial.c:750:	gs_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
serial.c:797:	port_num = tty->index;
serial.c:804:		return -ENODEV;
serial.c:812:		return -ENODEV;
serial.c:820:		return -ERESTARTSYS;
serial.c:823:	spin_lock_irqsave(&dev->dev_lock, flags);
serial.c:825:	if (dev->dev_config == GS_NO_CONFIG_ID) {
serial.c:829:		ret = -ENODEV;
serial.c:833:	port = dev->dev_port[port_num];
serial.c:838:		ret = -ENODEV;
serial.c:842:	spin_lock(&port->port_lock);
serial.c:843:	spin_unlock(&dev->dev_lock);
serial.c:845:	if (port->port_dev == NULL) {
serial.c:848:		ret = -EIO;
serial.c:852:	if (port->port_open_count > 0) {
serial.c:853:		++port->port_open_count;
serial.c:860:	tty->driver_data = NULL;
serial.c:863:	port->port_in_use = 1;
serial.c:866:	if (port->port_write_buf == NULL) {
serial.c:867:		spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:869:		spin_lock_irqsave(&port->port_lock, flags);
serial.c:872:		if (port->port_dev == NULL) {
serial.c:876:			port->port_in_use = 0;
serial.c:877:			ret = -EIO;
serial.c:881:		if ((port->port_write_buf=buf) == NULL) {
serial.c:884:			port->port_in_use = 0;
serial.c:885:			ret = -ENOMEM;
serial.c:894:	if (port->port_dev == NULL) {
serial.c:897:		port->port_in_use = 0;
serial.c:898:		ret = -EIO;
serial.c:902:	tty->driver_data = port;
serial.c:903:	port->port_tty = tty;
serial.c:904:	port->port_open_count = 1;
serial.c:905:	port->port_in_use = 0;
serial.c:912:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:917:	spin_unlock_irqrestore(&dev->dev_lock, flags);
serial.c:929:	struct gs_port *port = tty->driver_data;
serial.c:937:	gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
serial.c:939:	sem = &gs_open_close_sem[port->port_num];
serial.c:942:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:944:	if (port->port_open_count == 0) {
serial.c:947:			port->port_num, tty, file);
serial.c:951:	if (port->port_open_count > 1) {
serial.c:952:		--port->port_open_count;
serial.c:957:	if (port->port_dev == NULL) {
serial.c:964:	port->port_in_use = 1;
serial.c:965:	port->port_open_count = 0;
serial.c:969:	if (gs_buf_data_avail(port->port_write_buf) > 0) {
serial.c:970:		wait_cond_interruptible_timeout(port->port_write_wait,
serial.c:971:		port->port_dev == NULL
serial.c:972:		|| gs_buf_data_avail(port->port_write_buf) == 0,
serial.c:973:		&port->port_lock, flags, GS_CLOSE_TIMEOUT * HZ);
serial.c:978:	if (port->port_dev == NULL) {
serial.c:983:	gs_buf_clear(port->port_write_buf);
serial.c:985:	tty->driver_data = NULL;
serial.c:986:	port->port_tty = NULL;
serial.c:987:	port->port_in_use = 0;
serial.c:990:		port->port_num, tty, file);
serial.c:993:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1003:	struct gs_port *port = tty->driver_data;
serial.c:1008:		return -EIO;
serial.c:1011:	gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty,
serial.c:1017:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:1019:	if (port->port_dev == NULL) {
serial.c:1021:			port->port_num, tty);
serial.c:1022:		ret = -EIO;
serial.c:1026:	if (port->port_open_count == 0) {
serial.c:1028:			port->port_num, tty);
serial.c:1029:		ret = -EBADF;
serial.c:1033:	count = gs_buf_put(port->port_write_buf, buf, count);
serial.c:1035:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1039:	gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
serial.c:1045:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1055:	struct gs_port *port = tty->driver_data;
serial.c:1062:	gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p, %p, %p\n", port->port_num, tty, ch, __builtin_return_address(0), __builtin_return_address(1), __builtin_return_address(2));
serial.c:1064:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:1066:	if (port->port_dev == NULL) {
serial.c:1068:			port->port_num, tty);
serial.c:1072:	if (port->port_open_count == 0) {
serial.c:1074:			port->port_num, tty);
serial.c:1078:	gs_buf_put(port->port_write_buf, &ch, 1);
serial.c:1081:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1090:	struct gs_port *port = tty->driver_data;
serial.c:1097:	gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
serial.c:1099:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:1101:	if (port->port_dev == NULL) {
serial.c:1104:			port->port_num, tty);
serial.c:1108:	if (port->port_open_count == 0) {
serial.c:1110:			port->port_num, tty);
serial.c:1114:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1121:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1132:	struct gs_port *port = tty->driver_data;
serial.c:1138:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:1140:	if (port->port_dev != NULL && port->port_open_count > 0
serial.c:1141:	&& port->port_write_buf != NULL)
serial.c:1142:		room = gs_buf_space_avail(port->port_write_buf);
serial.c:1144:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1147:		port->port_num, tty, room);
serial.c:1159:	struct gs_port *port = tty->driver_data;
serial.c:1164:	spin_lock_irqsave(&port->port_lock, flags);
serial.c:1166:	if (port->port_dev != NULL && port->port_open_count > 0
serial.c:1167:	&& port->port_write_buf != NULL)
serial.c:1168:		chars = gs_buf_data_avail(port->port_write_buf);
serial.c:1170:	spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:1173:		port->port_num, tty, chars);
serial.c:1204:	struct gs_port *port = tty->driver_data;
serial.c:1208:		return -EIO;
serial.c:1212:		port->port_num, tty, file, cmd, arg);
serial.c:1217:	return -ENOIOCTLCMD;
serial.c:1246:		return -ENODEV;
serial.c:1249:	spin_lock_irqsave(&dev->dev_lock, flags);
serial.c:1251:	ep = dev->dev_in_ep;
serial.c:1253:	while(!list_empty(&dev->dev_req_list)) {
serial.c:1255:		req_entry = list_entry(dev->dev_req_list.next,
serial.c:1258:		req = req_entry->re_req;
serial.c:1260:		len = gs_send_packet(dev, req->buf, ep->maxpacket);
serial.c:1263:gs_debug_level(3, "gs_send: len=%d, 0x%2.2x 0x%2.2x 0x%2.2x ...\n", len, *((unsigned char *)req->buf), *((unsigned char *)req->buf+1), *((unsigned char *)req->buf+2));
serial.c:1264:			list_del(&req_entry->re_entry);
serial.c:1265:			req->length = len;
serial.c:1278:	spin_unlock_irqrestore(&dev->dev_lock, flags);
serial.c:1302:	/* TEMPORARY -- only port 0 is supported right now */
serial.c:1303:	port = dev->dev_port[0];
serial.c:1309:		return -EIO;
serial.c:1312:	spin_lock(&port->port_lock);
serial.c:1314:	len = gs_buf_data_avail(port->port_write_buf);
serial.c:1321:	size = gs_buf_get(port->port_write_buf, packet, size);
serial.c:1323:	if (port->port_tty)
serial.c:1324:		wake_up_interruptible(&port->port_tty->write_wait);
serial.c:1327:	spin_unlock(&port->port_lock);
serial.c:1350:	/* TEMPORARY -- only port 0 is supported right now */
serial.c:1351:	port = dev->dev_port[0];
serial.c:1355:			port->port_num);
serial.c:1356:		return -EIO;
serial.c:1359:	spin_lock(&port->port_lock);
serial.c:1361:	if (port->port_open_count == 0) {
serial.c:1363:			port->port_num);
serial.c:1364:		ret = -EIO;
serial.c:1368:	if (port->port_tty == NULL) {
serial.c:1370:			port->port_num);
serial.c:1371:		ret = -EIO;
serial.c:1375:	if (port->port_tty->magic != TTY_MAGIC) {
serial.c:1377:			port->port_num);
serial.c:1378:		ret = -EIO;
serial.c:1382:	len = (unsigned int)(TTY_FLIPBUF_SIZE - port->port_tty->flip.count);
serial.c:1387:		memcpy(port->port_tty->flip.char_buf_ptr, packet, size);
serial.c:1388:		port->port_tty->flip.char_buf_ptr += size;
serial.c:1389:		port->port_tty->flip.count += size;
serial.c:1390:		tty_flip_buffer_push(port->port_tty);
serial.c:1391:		wake_up_interruptible(&port->port_tty->read_wait);
serial.c:1397:	spin_unlock(&port->port_lock);
serial.c:1407:	struct gs_dev *dev = ep->driver_data;
serial.c:1414:	switch(req->status) {
serial.c:1417:		gs_recv_packet(dev, req->buf, req->actual);
serial.c:1419:		req->length = ep->maxpacket;
serial.c:1427:	case -ESHUTDOWN:
serial.c:1437:			req->status);
serial.c:1448:	struct gs_dev *dev = ep->driver_data;
serial.c:1449:	struct gs_req_entry *gs_req = req->context;
serial.c:1456:	switch(req->status) {
serial.c:1466:		spin_lock(&dev->dev_lock);
serial.c:1467:		list_add(&gs_req->re_entry, &dev->dev_req_list);
serial.c:1468:		spin_unlock(&dev->dev_lock);
serial.c:1474:	case -ESHUTDOWN:
serial.c:1483:			req->status);
serial.c:1540:			gadget->name);
serial.c:1551:	EP_IN_NAME = ep->name;
serial.c:1552:	ep->driver_data = ep;	/* claim the endpoint */
serial.c:1557:	EP_OUT_NAME = ep->name;
serial.c:1558:	ep->driver_data = ep;	/* claim the endpoint */
serial.c:1563:			printk(KERN_ERR "gs_bind: cannot run ACM on %s\n", gadget->name);
serial.c:1568:		EP_NOTIFY_NAME = ep->name;
serial.c:1569:		ep->driver_data = ep;	/* claim the endpoint */
serial.c:1574:	gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
serial.c:1581:	/* assume endpoints are dual-speed */
serial.c:1592:	if (gadget->is_otg) {
serial.c:1600:		return -ENOMEM;
serial.c:1604:		gadget->name);
serial.c:1607:	dev->dev_gadget = gadget;
serial.c:1608:	spin_lock_init(&dev->dev_lock);
serial.c:1609:	INIT_LIST_HEAD(&dev->dev_req_list);
serial.c:1619:	dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
serial.c:1621:	if (dev->dev_ctrl_req == NULL) {
serial.c:1623:		return -ENOMEM;
serial.c:1625:	dev->dev_ctrl_req->complete = gs_setup_complete;
serial.c:1627:	gadget->ep0->driver_data = dev;
serial.c:1635:	printk(KERN_ERR "gs_bind: cannot autoconfigure on %s\n", gadget->name);
serial.c:1636:	return -ENODEV;
serial.c:1653:		if (dev->dev_ctrl_req != NULL) {
serial.c:1654:			gs_free_req(gadget->ep0, dev->dev_ctrl_req);
serial.c:1655:			dev->dev_ctrl_req = NULL;
serial.c:1678:	int ret = -EOPNOTSUPP;
serial.c:1680:	struct usb_request *req = dev->dev_ctrl_req;
serial.c:1682:	switch (ctrl->bRequestType & USB_TYPE_MASK) {
serial.c:1693:			ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
serial.c:1694:			ctrl->wIndex, ctrl->wLength);
serial.c:1700:		req->length = ret;
serial.c:1701:		req->zero = ret < ctrl->wLength
serial.c:1702:				&& (ret % gadget->ep0->maxpacket) == 0;
serial.c:1703:		ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
serial.c:1707:			req->status = 0;
serial.c:1708:			gs_setup_complete(gadget->ep0, req);
serial.c:1719:	int ret = -EOPNOTSUPP;
serial.c:1721:	struct usb_request *req = dev->dev_ctrl_req;
serial.c:1723:	switch (ctrl->bRequest) {
serial.c:1725:		if (ctrl->bRequestType != USB_DIR_IN)
serial.c:1728:		switch (ctrl->wValue >> 8) {
serial.c:1730:			ret = min(ctrl->wLength,
serial.c:1732:			memcpy(req->buf, &gs_device_desc, ret);
serial.c:1737:			if (!gadget->is_dualspeed)
serial.c:1739:			ret = min(ctrl->wLength,
serial.c:1741:			memcpy(req->buf, &gs_qualifier_desc, ret);
serial.c:1745:			if (!gadget->is_dualspeed)
serial.c:1750:			ret = gs_build_config_buf(req->buf, gadget->speed,
serial.c:1751:				ctrl->wValue >> 8, ctrl->wValue & 0xff,
serial.c:1752:				gadget->is_otg);
serial.c:1754:				ret = min(ctrl->wLength, (u16)ret);
serial.c:1760:				ctrl->wValue & 0xff, req->buf);
serial.c:1762:				ret = min(ctrl->wLength, (u16)ret);
serial.c:1768:		if (ctrl->bRequestType != 0)
serial.c:1770:		spin_lock(&dev->dev_lock);
serial.c:1771:		ret = gs_set_config(dev, ctrl->wValue);
serial.c:1772:		spin_unlock(&dev->dev_lock);
serial.c:1776:		if (ctrl->bRequestType != USB_DIR_IN)
serial.c:1778:		*(u8 *)req->buf = dev->dev_config;
serial.c:1779:		ret = min(ctrl->wLength, (u16)1);
serial.c:1783:		if (ctrl->bRequestType != USB_RECIP_INTERFACE
serial.c:1784:		|| !dev->dev_config || ctrl->wIndex >= GS_MAX_NUM_INTERFACES)
serial.c:1786:		if (dev->dev_config == GS_BULK_CONFIG_ID
serial.c:1787:		&& ctrl->wIndex != GS_BULK_INTERFACE_ID)
serial.c:1790:		if (ctrl->wValue != 0)
serial.c:1792:		spin_lock(&dev->dev_lock);
serial.c:1800:		if (dev->dev_config != GS_BULK_CONFIG_ID
serial.c:1801:		&& ctrl->wIndex == GS_CONTROL_INTERFACE_ID) {
serial.c:1802:			if (dev->dev_notify_ep) {
serial.c:1803:				usb_ep_disable(dev->dev_notify_ep);
serial.c:1804:				usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc);
serial.c:1807:			usb_ep_disable(dev->dev_in_ep);
serial.c:1808:			usb_ep_disable(dev->dev_out_ep);
serial.c:1809:			usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc);
serial.c:1810:			usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc);
serial.c:1814:		spin_unlock(&dev->dev_lock);
serial.c:1818:		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
serial.c:1819:		|| dev->dev_config == GS_NO_CONFIG_ID)
serial.c:1821:		if (ctrl->wIndex >= GS_MAX_NUM_INTERFACES
serial.c:1822:		|| (dev->dev_config == GS_BULK_CONFIG_ID
serial.c:1823:		&& ctrl->wIndex != GS_BULK_INTERFACE_ID)) {
serial.c:1824:			ret = -EDOM;
serial.c:1828:		*(u8 *)req->buf = 0;
serial.c:1829:		ret = min(ctrl->wLength, (u16)1);
serial.c:1834:			ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
serial.c:1835:			ctrl->wIndex, ctrl->wLength);
serial.c:1845:	int ret = -EOPNOTSUPP;
serial.c:1847:	struct gs_port *port = dev->dev_port[0];	/* ACM only has one port */
serial.c:1848:	struct usb_request *req = dev->dev_ctrl_req;
serial.c:1850:	switch (ctrl->bRequest) {
serial.c:1852:		ret = min(ctrl->wLength,
serial.c:1855:			spin_lock(&port->port_lock);
serial.c:1856:			memcpy(&port->port_line_coding, req->buf, ret);
serial.c:1857:			spin_unlock(&port->port_lock);
serial.c:1862:		port = dev->dev_port[0];	/* ACM only has one port */
serial.c:1863:		ret = min(ctrl->wLength,
serial.c:1866:			spin_lock(&port->port_lock);
serial.c:1867:			memcpy(req->buf, &port->port_line_coding, ret);
serial.c:1868:			spin_unlock(&port->port_lock);
serial.c:1878:			ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
serial.c:1879:			ctrl->wIndex, ctrl->wLength);
serial.c:1891:	if (req->status || req->actual != req->length) {
serial.c:1893:			req->status, req->actual, req->length);
serial.c:1909:	spin_lock_irqsave(&dev->dev_lock, flags);
serial.c:1917:	/* re-allocate ports for the next connection */
serial.c:1919:		printk(KERN_ERR "gs_disconnect: cannot re-allocate ports\n");
serial.c:1921:	spin_unlock_irqrestore(&dev->dev_lock, flags);
serial.c:1939:	struct usb_gadget *gadget = dev->dev_gadget;
serial.c:1950:	if (config == dev->dev_config)
serial.c:1960:			return -EINVAL;
serial.c:1967:			return -EINVAL;
serial.c:1973:		return -EINVAL;
serial.c:1976:	dev->dev_config = config;
serial.c:1981:		&& strcmp(ep->name, EP_NOTIFY_NAME) == 0) {
serial.c:1983:				gadget->speed == USB_SPEED_HIGH,
serial.c:1988:				ep->driver_data = dev;
serial.c:1989:				dev->dev_notify_ep = ep;
serial.c:1990:				dev->dev_notify_ep_desc = ep_desc;
serial.c:1993:					ep->name, ret);
serial.c:1998:		else if (strcmp(ep->name, EP_IN_NAME) == 0) {
serial.c:2000:				gadget->speed == USB_SPEED_HIGH,
serial.c:2005:				ep->driver_data = dev;
serial.c:2006:				dev->dev_in_ep = ep;
serial.c:2007:				dev->dev_in_ep_desc = ep_desc;
serial.c:2010:					ep->name, ret);
serial.c:2015:		else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
serial.c:2017:				gadget->speed == USB_SPEED_HIGH,
serial.c:2022:				ep->driver_data = dev;
serial.c:2023:				dev->dev_out_ep = ep;
serial.c:2024:				dev->dev_out_ep_desc = ep_desc;
serial.c:2027:					ep->name, ret);
serial.c:2034:	if (dev->dev_in_ep == NULL || dev->dev_out_ep == NULL
serial.c:2035:	|| (config != GS_BULK_CONFIG_ID && dev->dev_notify_ep == NULL)) {
serial.c:2037:		ret = -ENODEV;
serial.c:2042:	ep = dev->dev_out_ep;
serial.c:2044:		if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) {
serial.c:2045:			req->complete = gs_read_complete;
serial.c:2052:			ret = -ENOMEM;
serial.c:2058:	ep = dev->dev_in_ep;
serial.c:2060:		if ((req_entry=gs_alloc_req_entry(ep, ep->maxpacket, GFP_ATOMIC))) {
serial.c:2061:			req_entry->re_req->complete = gs_write_complete;
serial.c:2062:			list_add(&req_entry->re_entry, &dev->dev_req_list);
serial.c:2065:			ret = -ENOMEM;
serial.c:2072:		gadget->speed == USB_SPEED_HIGH ? "high" : "full",
serial.c:2073:		config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM");
serial.c:2101:	if (dev->dev_config == GS_NO_CONFIG_ID)
serial.c:2104:	dev->dev_config = GS_NO_CONFIG_ID;
serial.c:2107:	while(!list_empty(&dev->dev_req_list)) {
serial.c:2108:		req_entry = list_entry(dev->dev_req_list.next,
serial.c:2110:		list_del(&req_entry->re_entry);
serial.c:2111:		gs_free_req_entry(dev->dev_in_ep, req_entry);
serial.c:2116:	if (dev->dev_notify_ep) {
serial.c:2117:		usb_ep_disable(dev->dev_notify_ep);
serial.c:2118:		dev->dev_notify_ep = NULL;
serial.c:2120:	if (dev->dev_in_ep) {
serial.c:2121:		usb_ep_disable(dev->dev_in_ep);
serial.c:2122:		dev->dev_in_ep = NULL;
serial.c:2124:	if (dev->dev_out_ep) {
serial.c:2125:		usb_ep_disable(dev->dev_out_ep);
serial.c:2126:		dev->dev_out_ep = NULL;
serial.c:2145:		return -EINVAL;
serial.c:2164:	/* for now, don't advertise srp-only devices */
serial.c:2172:	((struct usb_config_descriptor *)buf)->bDescriptorType = type;
serial.c:2193:		req->length = len;
serial.c:2194:		req->buf = kmalloc(len, kmalloc_flags);
serial.c:2195:		if (req->buf == NULL) {
serial.c:2212:		kfree(req->buf);
serial.c:2231:	req->re_req = gs_alloc_req(ep, len, kmalloc_flags);
serial.c:2232:	if (req->re_req == NULL) {
serial.c:2237:	req->re_req->context = req;
serial.c:2250:		if (req->re_req != NULL)
serial.c:2251:			gs_free_req(ep, req->re_req);
serial.c:2270:		return -EIO;
serial.c:2274:			return -ENOMEM;
serial.c:2277:		port->port_dev = dev;
serial.c:2278:		port->port_num = i;
serial.c:2279:		port->port_line_coding.dwDTERate = GS_DEFAULT_DTE_RATE;
serial.c:2280:		port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT;
serial.c:2281:		port->port_line_coding.bParityType = GS_DEFAULT_PARITY;
serial.c:2282:		port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS;
serial.c:2283:		spin_lock_init(&port->port_lock);
serial.c:2284:		init_waitqueue_head(&port->port_write_wait);
serial.c:2286:		dev->dev_port[i] = port;
serial.c:2312:		if ((port=dev->dev_port[i]) != NULL) {
serial.c:2313:			dev->dev_port[i] = NULL;
serial.c:2315:			spin_lock_irqsave(&port->port_lock, flags);
serial.c:2317:			if (port->port_write_buf != NULL) {
serial.c:2318:				gs_buf_free(port->port_write_buf);
serial.c:2319:				port->port_write_buf = NULL;
serial.c:2322:			if (port->port_open_count > 0 || port->port_in_use) {
serial.c:2323:				port->port_dev = NULL;
serial.c:2324:				wake_up_interruptible(&port->port_write_wait);
serial.c:2325:				if (port->port_tty) {
serial.c:2326:					wake_up_interruptible(&port->port_tty->read_wait);
serial.c:2327:					wake_up_interruptible(&port->port_tty->write_wait);
serial.c:2329:				spin_unlock_irqrestore(&port->port_lock, flags);
serial.c:2356:	gb->buf_buf = kmalloc(size, kmalloc_flags);
serial.c:2357:	if (gb->buf_buf == NULL) {
serial.c:2362:	gb->buf_size = size;
serial.c:2363:	gb->buf_get = gb->buf_put = gb->buf_buf;
serial.c:2376:		if (gb->buf_buf != NULL)
serial.c:2377:			kfree(gb->buf_buf);
serial.c:2390:		gb->buf_get = gb->buf_put;
serial.c:2403:		return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
serial.c:2417:		return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
serial.c:2444:	len = gb->buf_buf + gb->buf_size - gb->buf_put;
serial.c:2446:		memcpy(gb->buf_put, buf, len);
serial.c:2447:		memcpy(gb->buf_buf, buf+len, count - len);
serial.c:2448:		gb->buf_put = gb->buf_buf + count - len;
serial.c:2450:		memcpy(gb->buf_put, buf, count);
serial.c:2452:			gb->buf_put += count;
serial.c:2454:			gb->buf_put = gb->buf_buf;
serial.c:2482:	len = gb->buf_buf + gb->buf_size - gb->buf_get;
serial.c:2484:		memcpy(buf, gb->buf_get, len);
serial.c:2485:		memcpy(buf+len, gb->buf_buf, count - len);
serial.c:2486:		gb->buf_get = gb->buf_buf + count - len;
serial.c:2488:		memcpy(buf, gb->buf_get, count);
serial.c:2490:			gb->buf_get += count;
serial.c:2492:			gb->buf_get = gb->buf_buf;
usbstring.c:30:	 * BUT it currently rejects legit 4-byte UTF-8 code points,
usbstring.c:35:			// 2-byte sequence:
usbstring.c:46:			// 3-byte sequence (most CJKV characters):
usbstring.c:67:			// 4-byte sequence (surrogate pairs, currently rare):
usbstring.c:79:		len--;
usbstring.c:83:	return -1;
usbstring.c:88: * usb_gadget_get_string - fill out a string descriptor 
usbstring.c:89: * @table: of c strings encoded using UTF-8
usbstring.c:93: * Finds the UTF-8 string matching the ID, and converts it into a
usbstring.c:94: * string descriptor in utf16-le.
usbstring.c:99: * using this routine after choosing which set of UTF-8 strings to use.
usbstring.c:100: * Note that US-ASCII is a strict subset of UTF-8; any string bytes with
usbstring.c:101: * the eighth bit set will be multibyte UTF-8 characters, not ISO-8859/1
usbstring.c:114:		buf [2] = (u8) table->language;
usbstring.c:115:		buf [3] = (u8) (table->language >> 8);
usbstring.c:118:	for (s = table->strings; s && s->s; s++)
usbstring.c:119:		if (s->id == id)
usbstring.c:123:	if (!s || !s->s)
usbstring.c:124:		return -EINVAL;
usbstring.c:126:	/* string descriptors have length, tag, then UTF16-LE text */
usbstring.c:127:	len = min ((size_t) 126, strlen (s->s));
usbstring.c:129:	len = utf8_to_utf16le(s->s, (u16 *)&buf[2], len);
usbstring.c:131:		return -EINVAL;
zero.c:2: * zero.c -- Gadget Zero, for USB development
zero.c:4: * Copyright (C) 2003-2004 David Brownell
zero.c:16: * 3. The names of the above-listed copyright holders may not be used
zero.c:41: * can write a hardware-agnostic gadget driver running inside a USB device.
zero.c:47: * functional test of your device-side usb stack, or with "usb-skeleton".
zero.c:94:/*-------------------------------------------------------------------------*/
zero.c:104:/*-------------------------------------------------------------------------*/
zero.c:107: * driver assumes self-powered hardware, and
zero.c:111: * which is reasonable for most "bulk-only" drivers.
zero.c:116:/*-------------------------------------------------------------------------*/
zero.c:127:	 * - source data (in to host) and sink it (out from host)
zero.c:128:	 * - or loop it back (out from host back in to host)
zero.c:138:	dev_printk(level , &(d)->gadget->dev , fmt , ## args)
zero.c:162:/*-------------------------------------------------------------------------*/
zero.c:189:/*-------------------------------------------------------------------------*/
zero.c:193: * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
zero.c:194: * Instead:  allocate your own, using normal USB-IF procedures.
zero.c:198:#define DRIVER_PRODUCT_NUM	0xa4a0		/* Linux-USB "Gadget Zero" */
zero.c:204:/*-------------------------------------------------------------------------*/
zero.c:254:	.bMaxPower =		1,	/* self-powered */
zero.c:267:	.bMaxPower =		1,	/* self-powered */
zero.c:300:/* two full speed bulk endpoints; their use is config-dependent */
zero.c:393:#define ep_desc(g,hs,fs) (((g)->speed==USB_SPEED_HIGH)?(hs):(fs))
zero.c:405:/* static strings, in UTF-8 */
zero.c:416:	.language	= 0x0409,	/* en-us */
zero.c:425: *  - high speed support, including "other speed config" rules
zero.c:426: *  - multiple configurations
zero.c:427: *  - interfaces with alternate settings
zero.c:428: *  - embedded class or vendor-specific descriptors
zero.c:446:	int				hs = (gadget->speed == USB_SPEED_HIGH);
zero.c:451:		return -EINVAL;
zero.c:467:	/* for now, don't advertise srp-only devices */
zero.c:468:	if (!gadget->is_otg)
zero.c:477:	((struct usb_config_descriptor *) buf)->bDescriptorType = type;
zero.c:481:/*-------------------------------------------------------------------------*/
zero.c:490:		req->length = length;
zero.c:491:		req->buf = usb_ep_alloc_buffer (ep, length,
zero.c:492:				&req->dma, GFP_ATOMIC);
zero.c:493:		if (!req->buf) {
zero.c:503:	if (req->buf)
zero.c:504:		usb_ep_free_buffer (ep, req->buf, req->dma, req->length);
zero.c:508:/*-------------------------------------------------------------------------*/
zero.c:520:	u8		*buf = req->buf;
zero.c:522:	for (i = 0; i < req->actual; i++, buf++) {
zero.c:524:		/* all-zeroes has no synchronization issues */
zero.c:529:		/* mod63 stays in sync with short-terminated transfers,
zero.c:541:		return -EINVAL;
zero.c:554:	u8		*buf = req->buf;
zero.c:558:		memset (req->buf, 0, req->length);
zero.c:561:		for  (i = 0; i < req->length; i++)
zero.c:573:	struct zero_dev	*dev = ep->driver_data;
zero.c:574:	int		status = req->status;
zero.c:579:		if (ep == dev->out_ep)
zero.c:586:	case -ECONNABORTED: 		/* hardware forced ep reset */
zero.c:587:	case -ECONNRESET:		/* request dequeued */
zero.c:588:	case -ESHUTDOWN:		/* disconnect from host */
zero.c:589:		VDBG (dev, "%s gone (%d), %d/%d\n", ep->name, status,
zero.c:590:				req->actual, req->length);
zero.c:591:		if (ep == dev->out_ep)
zero.c:596:	case -EOVERFLOW:		/* buffer overrun on read means that
zero.c:602:		DBG (dev, "%s complete --> %d, %d/%d\n", ep->name,
zero.c:603:				status, req->actual, req->length);
zero.c:605:	case -EREMOTEIO:		/* short read */
zero.c:611:		ERROR (dev, "kill %s:  resubmit %d bytes --> %d\n",
zero.c:612:				ep->name, req->length, status);
zero.c:628:	memset (req->buf, 0, req->length);
zero.c:629:	req->complete = source_sink_complete;
zero.c:631:	if (strcmp (ep->name, EP_IN_NAME) == 0)
zero.c:632:		reinit_write_data (ep->driver_data, ep, req);
zero.c:636:		struct zero_dev	*dev = ep->driver_data;
zero.c:638:		ERROR (dev, "start %s --> %d\n", ep->name, status);
zero.c:651:	struct usb_gadget	*gadget = dev->gadget;
zero.c:657:		if (strcmp (ep->name, EP_IN_NAME) == 0) {
zero.c:661:				ep->driver_data = dev;
zero.c:663:					dev->in_ep = ep;
zero.c:667:				result = -EIO;
zero.c:671:		} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
zero.c:675:				ep->driver_data = dev;
zero.c:677:					dev->out_ep = ep;
zero.c:681:				result = -EIO;
zero.c:689:		ERROR (dev, "can't start %s, result %d\n", ep->name, result);
zero.c:699:/*-------------------------------------------------------------------------*/
zero.c:703:	struct zero_dev	*dev = ep->driver_data;
zero.c:704:	int		status = req->status;
zero.c:709:		if (ep == dev->out_ep) {
zero.c:711:			req->zero = (req->actual < req->length);
zero.c:712:			req->length = req->actual;
zero.c:713:			status = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
zero.c:719:				ep->name, dev->in_ep->name,
zero.c:724:		req->length = buflen;
zero.c:725:		status = usb_ep_queue (dev->out_ep, req, GFP_ATOMIC);
zero.c:733:		ERROR (dev, "%s loop complete --> %d, %d/%d\n", ep->name,
zero.c:734:				status, req->actual, req->length);
zero.c:742:	case -ECONNABORTED: 		/* hardware forced ep reset */
zero.c:743:	case -ECONNRESET:		/* request dequeued */
zero.c:744:	case -ESHUTDOWN:		/* disconnect from host */
zero.c:755:	struct usb_gadget	*gadget = dev->gadget;
zero.c:761:		if (strcmp (ep->name, EP_IN_NAME) == 0) {
zero.c:765:				ep->driver_data = dev;
zero.c:766:				dev->in_ep = ep;
zero.c:771:		} else if (strcmp (ep->name, EP_OUT_NAME) == 0) {
zero.c:775:				ep->driver_data = dev;
zero.c:776:				dev->out_ep = ep;
zero.c:785:		ERROR (dev, "can't enable %s, result %d\n", ep->name, result);
zero.c:797:		ep = dev->out_ep;
zero.c:801:				req->complete = loopback_complete;
zero.c:804:					DBG (dev, "%s queue req --> %d\n",
zero.c:805:							ep->name, result);
zero.c:807:				result = -ENOMEM;
zero.c:817:/*-------------------------------------------------------------------------*/
zero.c:821:	if (dev->config == 0)
zero.c:829:	if (dev->in_ep) {
zero.c:830:		usb_ep_disable (dev->in_ep);
zero.c:831:		dev->in_ep = NULL;
zero.c:833:	if (dev->out_ep) {
zero.c:834:		usb_ep_disable (dev->out_ep);
zero.c:835:		dev->out_ep = NULL;
zero.c:837:	dev->config = 0;
zero.c:838:	del_timer (&dev->resume);
zero.c:855:	struct usb_gadget	*gadget = dev->gadget;
zero.c:857:	if (number == dev->config)
zero.c:860:	if (gadget_is_sa1100 (gadget) && dev->config) {
zero.c:863:		return -ESPIPE;
zero.c:875:		result = -EINVAL;
zero.c:881:	if (!result && (!dev->in_ep || !dev->out_ep))
zero.c:882:		result = -ENODEV;
zero.c:888:		switch (gadget->speed) {
zero.c:895:		dev->config = number;
zero.c:903:/*-------------------------------------------------------------------------*/
zero.c:907:	if (req->status || req->actual != req->length)
zero.c:908:		DBG ((struct zero_dev *) ep->driver_data,
zero.c:909:				"setup complete --> %d, %d/%d\n",
zero.c:910:				req->status, req->actual, req->length);
zero.c:918: * the work is in config-specific setup.
zero.c:924:	struct usb_request	*req = dev->req;
zero.c:925:	int			value = -EOPNOTSUPP;
zero.c:927:	/* usually this stores reply data in the pre-allocated ep0 buffer,
zero.c:930:	req->zero = 0;
zero.c:931:	switch (ctrl->bRequest) {
zero.c:934:		if (ctrl->bRequestType != USB_DIR_IN)
zero.c:936:		switch (ctrl->wValue >> 8) {
zero.c:939:			value = min (ctrl->wLength, (u16) sizeof device_desc);
zero.c:940:			memcpy (req->buf, &device_desc, value);
zero.c:944:			if (!gadget->is_dualspeed)
zero.c:946:			value = min (ctrl->wLength, (u16) sizeof dev_qualifier);
zero.c:947:			memcpy (req->buf, &dev_qualifier, value);
zero.c:951:			if (!gadget->is_dualspeed)
zero.c:956:			value = config_buf (gadget, req->buf,
zero.c:957:					ctrl->wValue >> 8,
zero.c:958:					ctrl->wValue & 0xff);
zero.c:960:				value = min (ctrl->wLength, (u16) value);
zero.c:967:			 * any UTF-8 characters
zero.c:970:					ctrl->wValue & 0xff, req->buf);
zero.c:972:				value = min (ctrl->wLength, (u16) value);
zero.c:979:		if (ctrl->bRequestType != 0)
zero.c:981:		if (gadget->a_hnp_support)
zero.c:983:		else if (gadget->a_alt_hnp_support)
zero.c:987:		spin_lock (&dev->lock);
zero.c:988:		value = zero_set_config (dev, ctrl->wValue, GFP_ATOMIC);
zero.c:989:		spin_unlock (&dev->lock);
zero.c:992:		if (ctrl->bRequestType != USB_DIR_IN)
zero.c:994:		*(u8 *)req->buf = dev->config;
zero.c:995:		value = min (ctrl->wLength, (u16) 1);
zero.c:1003:		if (ctrl->bRequestType != USB_RECIP_INTERFACE)
zero.c:1005:		spin_lock (&dev->lock);
zero.c:1006:		if (dev->config && ctrl->wIndex == 0 && ctrl->wValue == 0) {
zero.c:1007:			u8		config = dev->config;
zero.c:1011:			 * and re-inits endpoint state (toggle etc)
zero.c:1020:		spin_unlock (&dev->lock);
zero.c:1023:		if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
zero.c:1025:		if (!dev->config)
zero.c:1027:		if (ctrl->wIndex != 0) {
zero.c:1028:			value = -EDOM;
zero.c:1031:		*(u8 *)req->buf = 0;
zero.c:1032:		value = min (ctrl->wLength, (u16) 1);
zero.c:1036:	 * These are the same vendor-specific requests supported by
zero.c:1038:	 * device spec by allowing multiple-packet requests.
zero.c:1040:	case 0x5b:	/* control WRITE test -- fill the buffer */
zero.c:1041:		if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
zero.c:1043:		if (ctrl->wValue || ctrl->wIndex)
zero.c:1046:		if (ctrl->wLength > USB_BUFSIZ)
zero.c:1048:		value = ctrl->wLength;
zero.c:1050:	case 0x5c:	/* control READ test -- return the buffer */
zero.c:1051:		if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
zero.c:1053:		if (ctrl->wValue || ctrl->wIndex)
zero.c:1056:		if (ctrl->wLength > USB_BUFSIZ
zero.c:1057:				|| ctrl->wLength != req->length)
zero.c:1059:		value = ctrl->wLength;
zero.c:1066:			ctrl->bRequestType, ctrl->bRequest,
zero.c:1067:			ctrl->wValue, ctrl->wIndex, ctrl->wLength);
zero.c:1072:		req->length = value;
zero.c:1073:		req->zero = value < ctrl->wLength
zero.c:1074:				&& (value % gadget->ep0->maxpacket) == 0;
zero.c:1075:		value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
zero.c:1077:			DBG (dev, "ep_queue --> %d\n", value);
zero.c:1078:			req->status = 0;
zero.c:1079:			zero_setup_complete (gadget->ep0, req);
zero.c:1093:	spin_lock_irqsave (&dev->lock, flags);
zero.c:1096:	/* a more significant application might have some non-usb
zero.c:1100:	spin_unlock_irqrestore (&dev->lock, flags);
zero.c:1116:	if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
zero.c:1117:		status = usb_gadget_wakeup (dev->gadget);
zero.c:1118:		DBG (dev, "wakeup --> %d\n", status);
zero.c:1122:/*-------------------------------------------------------------------------*/
zero.c:1132:	if (dev->req)
zero.c:1133:		free_ep_req (gadget->ep0, dev->req);
zero.c:1134:	del_timer_sync (&dev->resume);
zero.c:1145:	/* Bulk-only drivers like this one SHOULD be able to
zero.c:1154:			shortname, gadget->name);
zero.c:1155:		return -ENODEV;
zero.c:1157:	EP_IN_NAME = ep->name;
zero.c:1158:	ep->driver_data = ep;	/* claim */
zero.c:1163:	EP_OUT_NAME = ep->name;
zero.c:1164:	ep->driver_data = ep;	/* claim */
zero.c:1170:	 * with different host-visible configurations or behavior
zero.c:1171:	 * restrictions -- using ep1in/ep2out vs ep1out/ep3in, etc
zero.c:1200:		 * it SHOULD NOT have problems with bulk-capable hardware.
zero.c:1204:		 * can need hardware-specific attention though.
zero.c:1207:			shortname, gadget->name);
zero.c:1215:		return -ENOMEM;
zero.c:1217:	spin_lock_init (&dev->lock);
zero.c:1218:	dev->gadget = gadget;
zero.c:1222:	dev->req = usb_ep_alloc_request (gadget->ep0, GFP_KERNEL);
zero.c:1223:	if (!dev->req)
zero.c:1225:	dev->req->buf = usb_ep_alloc_buffer (gadget->ep0, USB_BUFSIZ,
zero.c:1226:				&dev->req->dma, GFP_KERNEL);
zero.c:1227:	if (!dev->req->buf)
zero.c:1230:	dev->req->complete = zero_setup_complete;
zero.c:1232:	device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
zero.c:1238:	/* and that all endpoints are dual-speed */
zero.c:1243:	if (gadget->is_otg) {
zero.c:1249:	if (gadget->is_otg) {
zero.c:1257:	init_timer (&dev->resume);
zero.c:1258:	dev->resume.function = zero_autoresume;
zero.c:1259:	dev->resume.data = (unsigned long) dev;
zero.c:1265:	gadget->ep0->driver_data = dev;
zero.c:1268:	INFO (dev, "using %s, OUT %s IN %s\n", gadget->name,
zero.c:1273:		gadget->name);
zero.c:1279:	return -ENOMEM;
zero.c:1282:/*-------------------------------------------------------------------------*/
zero.c:1289:	if (gadget->speed == USB_SPEED_UNKNOWN)
zero.c:1293:		mod_timer (&dev->resume, jiffies + (HZ * autoresume));
zero.c:1305:	del_timer (&dev->resume);
zero.c:1309:/*-------------------------------------------------------------------------*/
