自学教程：C++ usb_maxpacket函数代码示例

int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,		    int len){	int dir_out = usb_pipeout(pipe);	int ep = usb_pipeendpoint(pipe);	int max = usb_maxpacket(dev, pipe);	int done = 0;	PDEBUG(7, "dev = %ld pipe = %ld buf = %p size = %d dir_out = %d/n",	       usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);	dev->status = 0;	sl811_write(SL811_DEV_A, usb_pipedevice(pipe));	sl811_write(SL811_PIDEP_A, PIDEP(!dir_out ? USB_PID_IN : USB_PID_OUT, ep));	while (done < len) {		int res = sl811_send_packet(dev, pipe, (__u8*)buffer+done,					    max > len - done ? len - done : max);		if (res < 0) {			dev->status = -res;			return res;		}		if (!dir_out && res < max) /* short packet */			break;		done += res;		usb_dotoggle(dev, ep, dir_out);	}	dev->act_len = done;	return 0;}

static int init_status (struct usbnet *dev, struct usb_interface *intf){	char		*buf = NULL;	unsigned	pipe = 0;	unsigned	maxp;	unsigned	period;	if (!dev->driver_info->status)		return 0;	pipe = usb_rcvintpipe (dev->udev,			dev->status->desc.bEndpointAddress				& USB_ENDPOINT_NUMBER_MASK);	maxp = usb_maxpacket (dev->udev, pipe, 0);	/* avoid 1 msec chatter:  min 8 msec poll rate */	period = max ((int) dev->status->desc.bInterval,		(dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);	buf = kmalloc (maxp, GFP_KERNEL);	if (buf) {		dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);		if (!dev->interrupt) {			kfree (buf);			return -ENOMEM;		} else {			usb_fill_int_urb(dev->interrupt, dev->udev, pipe,				buf, maxp, intr_complete, dev, period);			dev_dbg(&intf->dev,				"status ep%din, %d bytes period %d/n",				usb_pipeendpoint(pipe), maxp, period);		}	}	return 0;}

int tm6000_start_stream(struct tm6000_core *dev){	int ret;	unsigned int pipe, size;	struct tm6000_dvb *dvb = dev->dvb;	printk(KERN_INFO "tm6000: got start stream request %s/n", __FUNCTION__);	if (dev->mode != TM6000_MODE_DIGITAL) {		tm6000_init_digital_mode(dev);		dev->mode = TM6000_MODE_DIGITAL;	}	dvb->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);	if (dvb->bulk_urb == NULL) {		printk(KERN_ERR "tm6000: couldn't allocate urb/n");		return -ENOMEM;	}	pipe = usb_rcvbulkpipe(dev->udev, dev->bulk_in.endp->desc.bEndpointAddress							  & USB_ENDPOINT_NUMBER_MASK);	size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));	size = size * 15; /* 512 x 8 or 12 or 15 */	dvb->bulk_urb->transfer_buffer = kzalloc(size, GFP_KERNEL);	if (dvb->bulk_urb->transfer_buffer == NULL) {		usb_free_urb(dvb->bulk_urb);		printk(KERN_ERR "tm6000: couldn't allocate transfer buffer!/n");		return -ENOMEM;	}	usb_fill_bulk_urb(dvb->bulk_urb, dev->udev, pipe,						 dvb->bulk_urb->transfer_buffer,						 size,						 tm6000_urb_received, dev);	ret = usb_clear_halt(dev->udev, pipe);	if (ret < 0) {		printk(KERN_ERR "tm6000: error %i in %s during pipe reset/n",							ret, __FUNCTION__);		return ret;	} else		printk(KERN_ERR "tm6000: pipe resetted/n");/*	mutex_lock(&tm6000_driver.open_close_mutex); */	ret = usb_submit_urb(dvb->bulk_urb, GFP_KERNEL);/*	mutex_unlock(&tm6000_driver.open_close_mutex); */	if (ret) {		printk(KERN_ERR "tm6000: submit of urb failed (error=%i)/n",									ret);		kfree(dvb->bulk_urb->transfer_buffer);		usb_free_urb(dvb->bulk_urb);		return ret;	}	return 0;}

//.........这里部分代码省略......... * some URB is always on the endpoint's queue (except possibly for short * periods during completion callacks).  When there is no longer an urb * queued, the endpoint's bandwidth reservation is canceled.  This means * drivers can use their completion handlers to ensure they keep bandwidth * they need, by reinitializing and resubmitting the just-completed urb * until the driver longer needs that periodic bandwidth. * * Memory Flags: * * The general rules for how to decide which mem_flags to use * are the same as for kmalloc.  There are four * different possible values; GFP_KERNEL, GFP_NOFS, GFP_NOIO and * GFP_ATOMIC. * * GFP_NOFS is not ever used, as it has not been implemented yet. * * GFP_ATOMIC is used when *   (a) you are inside a completion handler, an interrupt, bottom half, *       tasklet or timer, or *   (b) you are holding a spinlock or rwlock (does not apply to *       semaphores), or *   (c) current->state != TASK_RUNNING, this is the case only after *       you've changed it. *  * GFP_NOIO is used in the block io path and error handling of storage * devices. * * All other situations use GFP_KERNEL. * * Some more specific rules for mem_flags can be inferred, such as *  (1) start_xmit, timeout, and receive methods of network drivers must *      use GFP_ATOMIC (they are called with a spinlock held); *  (2) queuecommand methods of scsi drivers must use GFP_ATOMIC (also *      called with a spinlock held); *  (3) If you use a kernel thread with a network driver you must use *      GFP_NOIO, unless (b) or (c) apply; *  (4) after you have done a down() you can use GFP_KERNEL, unless (b) or (c) *      apply or your are in a storage driver's block io path; *  (5) USB probe and disconnect can use GFP_KERNEL unless (b) or (c) apply; and *  (6) changing firmware on a running storage or net device uses *      GFP_NOIO, unless b) or c) apply * */int usb_submit_urb(struct urb *urb, gfp_t mem_flags){	int			pipe, temp, max;	struct usb_device	*dev;	int			is_out;	if (!urb || urb->hcpriv || !urb->complete)		return -EINVAL;	if (!(dev = urb->dev) ||	    (dev->state < USB_STATE_DEFAULT) ||	    (!dev->bus) || (dev->devnum <= 0))		return -ENODEV;	if (dev->bus->controller->power.power_state.event != PM_EVENT_ON			|| dev->state == USB_STATE_SUSPENDED)		return -EHOSTUNREACH;	urb->status = -EINPROGRESS;	urb->actual_length = 0;	/* Lots of sanity checks, so HCDs can rely on clean data	 * and don't need to duplicate tests	 */	pipe = urb->pipe;	temp = usb_pipetype(pipe);	is_out = usb_pipeout(pipe);	if (!usb_pipecontrol(pipe) && dev->state < USB_STATE_CONFIGURED)		return -ENODEV;	/* FIXME there should be a sharable lock protecting us against	 * config/altsetting changes and disconnects, kicking in here.	 * (here == before maxpacket, and eventually endpoint type,	 * checks get made.)	 */	max = usb_maxpacket(dev, pipe, is_out);	if (max <= 0) {		dev_dbg(&dev->dev,			"bogus endpoint ep%d%s in %s (bad maxpacket %d)/n",			usb_pipeendpoint(pipe), is_out ? "out" : "in",			__FUNCTION__, max);		return -EMSGSIZE;	}	/* periodic transfers limit size per frame/uframe,	 * but drivers only control those sizes for ISO.	 * while we're checking, initialize return status.	 */	if (temp == PIPE_ISOCHRONOUS) {		int	n, len;		/* "high bandwidth" mode, 1-3 packets/uframe? */		if (dev->speed == USB_SPEED_HIGH) {			int	mult = 1 + ((max >> 11) & 0x03);			max &= 0x07ff;			max *= mult;		}

static void rt2x00usb_assign_endpoint(struct data_queue *queue,                                      struct usb_endpoint_descriptor *ep_desc){    struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);    int pipe;    queue->usb_endpoint = usb_endpoint_num(ep_desc);    if (queue->qid == QID_RX) {        pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);        queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0);    } else {        pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);        queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1);    }    if (!queue->usb_maxpacket)        queue->usb_maxpacket = 1;}

int usbnet_probe(struct usb_device *usbdev, const struct usb_device_id *prod){	struct usbnet *undev;	struct eth_device *edev;	struct driver_info *info;	int status;	dev_dbg(&usbdev->dev, "%s/n", __func__);	undev = xzalloc(sizeof (*undev));	usbdev->drv_data = undev;	edev = &undev->edev;	undev->udev = usbdev;	edev->open = usbnet_open,	edev->init = usbnet_init,	edev->send = usbnet_send,	edev->recv = usbnet_recv,	edev->halt = usbnet_halt,	edev->priv = undev;	edev->dev = usbdev->dev; /* will be overwritten by eth_register */	info = (struct driver_info *)prod->driver_info;	undev->driver_info = info;	if (info->bind) {		status = info->bind (undev);		if (status < 0)			goto out1;	}	if (!undev->rx_urb_size)		undev->rx_urb_size = 1514; /* FIXME: What to put here? */	undev->maxpacket = usb_maxpacket(undev->udev, undev->out);	eth_register(edev);	return 0;out1:	dev_dbg(&edev->dev, "err: %d/n", status);	return status;}

static int __tm6000_ir_int_start(struct rc_dev *rc){	struct tm6000_IR *ir = rc->priv;	struct tm6000_core *dev;	int pipe, size;	int err = -ENOMEM;	if (!ir)		return -ENODEV;	dev = ir->dev;	dprintk(2, "%s/n",__func__);	ir->int_urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!ir->int_urb)		return -ENOMEM;	pipe = usb_rcvintpipe(dev->udev,		dev->int_in.endp->desc.bEndpointAddress		& USB_ENDPOINT_NUMBER_MASK);	size = usb_maxpacket(dev->udev, pipe, usb_pipeout(pipe));	dprintk(1, "IR max size: %d/n", size);	ir->int_urb->transfer_buffer = kzalloc(size, GFP_ATOMIC);	if (ir->int_urb->transfer_buffer == NULL) {		usb_free_urb(ir->int_urb);		return err;	}	dprintk(1, "int interval: %d/n", dev->int_in.endp->desc.bInterval);	usb_fill_int_urb(ir->int_urb, dev->udev, pipe,		ir->int_urb->transfer_buffer, size,		tm6000_ir_urb_received, dev,		dev->int_in.endp->desc.bInterval);	ir->submit_urb = 1;	schedule_delayed_work(&ir->work, msecs_to_jiffies(URB_SUBMIT_DELAY));	return 0;}

/* * Receive one interrupt buffer, without timeouts, but allowing early * termination.  Return codes are USB_STOR_XFER_xxx. * * This routine always uses us->recv_intr_pipe as the pipe and * us->ep_bInterval as the interrupt interval. */static int usb_stor_intr_transfer(struct us_data *us, void *buf,				  unsigned int length){	int result;	unsigned int pipe = us->recv_intr_pipe;	unsigned int maxp;	usb_stor_dbg(us, "xfer %u bytes/n", length);	/* calculate the max packet size */	maxp = usb_maxpacket(us->pusb_dev, pipe, usb_pipeout(pipe));	if (maxp > length)		maxp = length;	/* fill and submit the URB */	usb_fill_int_urb(us->current_urb, us->pusb_dev, pipe, buf,			maxp, usb_stor_blocking_completion, NULL,			us->ep_bInterval);	result = usb_stor_msg_common(us, 0);	return interpret_urb_result(us, pipe, length, result,			us->current_urb->actual_length);}

/*-------------------------------------------------------------------*/static void dabusb_iso_complete (struct urb *purb, struct pt_regs *regs){	pbuff_t b = purb->context;	pdabusb_t s = b->s;	int i;	int len;	int dst = 0;	void *buf = purb->transfer_buffer;	dbg("dabusb_iso_complete");	// process if URB was not killed	if (purb->status != -ENOENT) {		unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);		int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));		for (i = 0; i < purb->number_of_packets; i++)			if (!purb->iso_frame_desc[i].status) {				len = purb->iso_frame_desc[i].actual_length;				if (len <= pipesize) {					memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);					dst += len;				}				else					err("dabusb_iso_complete: invalid len %d", len);			}			else				warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);		if (dst != purb->actual_length)			err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);	}	if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {		s->overruns++;		err("overrun (%d)", s->overruns);	}	wake_up (&s->wait);}

//A dedicated kernel thread is running to poll USB mouse input looply.static DWORD USB_Poll_Thread(LPVOID pData){	__USB_KEYBOARD_DATA  UsbKeyboardData;	struct usb_device*              pUsbDev = NULL;	struct usb_interface*           pUsbInt = NULL;	struct usb_endpoint_descriptor* pED = NULL;	//The pUsbKeyboardDev should be initialized before this thread is running.	if (NULL == pUsbKeyboardDev)	{		BUG();		return 0;	}	pUsbDev = (struct usb_device*)pUsbKeyboardDev->lpPrivateInfo;	pUsbInt = &pUsbDev->config.if_desc[pUsbKeyboardDev->dwNumber & 0xFFFF];	pED = &pUsbInt->ep_desc[0];	//Initialize the USB mouse private data.	UsbKeyboardData.ulIntPipe = usb_rcvintpipe(pUsbDev, pED->bEndpointAddress);	UsbKeyboardData.intInterval = pED->bInterval;	UsbKeyboardData.inputPktSize = min(usb_maxpacket(pUsbDev, UsbKeyboardData.ulIntPipe), MAX_USBKEYBOARD_BUFF_LEN);	//Main polling loop.	while (TRUE)	{		if (!USBManager.InterruptMessage(pUsbKeyboardDev, UsbKeyboardData.ulIntPipe,			&UsbKeyboardData.KeycodeBuffer[0], UsbKeyboardData.inputPktSize, UsbKeyboardData.intInterval))		{			//Interpret the USB input data,translate it to kernel message and delivery to kernel.			DoKeyboardMessage(&UsbKeyboardData);		}	}	return 1;}

/** Initializes a QH structure. * * @param[in] _hcd The HCD state structure for the DWC OTG controller. * @param[in] _qh The QH to init. * @param[in] _urb Holds the information about the device/endpoint that we need * to initialize the QH. */#define SCHEDULE_SLOP 10#define SCHEDULE_SPLIT_SLOP	10  /* 1 == 125us,  10 -> 1.25ms, 20 -> 2.5ms, */void dwc_otg_hcd_qh_init(dwc_otg_hcd_t * _hcd, dwc_otg_qh_t * _qh,			 struct urb *_urb){	memset(_qh, 0, sizeof(dwc_otg_qh_t));	/* Initialize QH */	switch (usb_pipetype(_urb->pipe)) {	case PIPE_CONTROL:		_qh->ep_type = USB_ENDPOINT_XFER_CONTROL;		break;	case PIPE_BULK:		_qh->ep_type = USB_ENDPOINT_XFER_BULK;		break;	case PIPE_ISOCHRONOUS:		_qh->ep_type = USB_ENDPOINT_XFER_ISOC;		break;	case PIPE_INTERRUPT:		_qh->ep_type = USB_ENDPOINT_XFER_INT;		break;	}	_qh->ep_is_in = usb_pipein(_urb->pipe) ? 1 : 0;	_qh->data_toggle = DWC_OTG_HC_PID_DATA0;	_qh->maxp =	    usb_maxpacket(_urb->dev, _urb->pipe, !(usb_pipein(_urb->pipe)));	INIT_LIST_HEAD(&_qh->qtd_list);	INIT_LIST_HEAD(&_qh->qh_list_entry);	_qh->channel = NULL;	/* FS/LS Enpoint on HS Hub 	 * NOT virtual root hub */	_qh->do_split = 0;	if (((_urb->dev->speed == USB_SPEED_LOW) ||	     (_urb->dev->speed == USB_SPEED_FULL)) &&	    (_urb->dev->tt) && (_urb->dev->tt->hub)	    && (_urb->dev->tt->hub->devnum != 1)) {		DWC_DEBUGPL(DBG_HCD,			    "QH init: EP %d: TT found at hub addr %d, for port %d/n",			    usb_pipeendpoint(_urb->pipe),			    _urb->dev->tt->hub->devnum, _urb->dev->ttport);		_qh->do_split = 1;	}	if (_qh->ep_type == USB_ENDPOINT_XFER_INT ||	    _qh->ep_type == USB_ENDPOINT_XFER_ISOC) {		/* Compute scheduling parameters once and save them. */		hprt0_data_t hprt;		/** @todo Account for split transfers in the bus time. */		int bytecount =		    dwc_hb_mult(_qh->maxp) * dwc_max_packet(_qh->maxp);		int usecs = /*FIXME: hardcode to highspeed, to fix Full/Low speed device via Hub*/		    usb_calc_bus_time(/*_urb->dev->speed*/USB_SPEED_HIGH, usb_pipein(_urb->pipe),				      (_qh->ep_type == USB_ENDPOINT_XFER_ISOC),				      bytecount);		_qh->usecs = NS_TO_US(usecs);		/* Start in a slightly future (micro)frame. */		_qh->sched_frame = dwc_frame_num_inc(_hcd->frame_number,						     SCHEDULE_SLOP);		_qh->interval = _urb->interval;#if 0		/* Increase interrupt polling rate for debugging. */		if (_qh->ep_type == USB_ENDPOINT_XFER_INT) {			_qh->interval = 8;		}#endif		hprt.d32 = dwc_read_reg32(_hcd->core_if->host_if->hprt0);		if ((hprt.b.prtspd == DWC_HPRT0_PRTSPD_HIGH_SPEED) &&		    ((_urb->dev->speed == USB_SPEED_LOW) ||		     (_urb->dev->speed == USB_SPEED_FULL))) {			_qh->interval *= 8;			_qh->sched_frame |= 0x7;			_qh->start_split_frame = _qh->sched_frame;		}	}else{		if(_qh->do_split){			_qh->interval = SCHEDULE_SPLIT_SLOP;			_qh->sched_frame = dwc_frame_num_inc(_hcd->frame_number,						     _qh->interval);		};	}	DWC_DEBUGPL(DBG_HCD, "DWC OTG HCD QH Initialized/n");	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - qh = %p/n", _qh);	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - Device Address = %d/n",		    _urb->dev->devnum);	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - Endpoint %d, %s/n",		    usb_pipeendpoint(_urb->pipe),		    usb_pipein(_urb->pipe) == USB_DIR_IN ? "IN" : "OUT");//.........这里部分代码省略.........

//.........这里部分代码省略.........	dev->net = net;	strcpy (net->name, "usb%d");	memcpy (net->dev_addr, node_id, sizeof node_id);	/* rx and tx sides can use different message sizes;	 * bind() should set rx_urb_size in that case.	 */	dev->hard_mtu = net->mtu + net->hard_header_len;#if 0// dma_supported() is deeply broken on almost all architectures	// possible with some EHCI controllers	if (dma_supported (&udev->dev, DMA_BIT_MASK(64)))		net->features |= NETIF_F_HIGHDMA;#endif	net->netdev_ops = &usbnet_netdev_ops;	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;	net->ethtool_ops = &usbnet_ethtool_ops;	// allow device-specific bind/init procedures	// NOTE net->name still not usable ...	if (info->bind) {		status = info->bind (dev, udev);		if (status < 0)			goto out1;		// heuristic:  "usb%d" for links we know are two-host,		// else "eth%d" when there's reasonable doubt.  userspace		// can rename the link if it knows better.		if ((dev->driver_info->flags & FLAG_ETHER) != 0 &&		    (net->dev_addr [0] & 0x02) == 0)			strcpy (net->name, "eth%d");		/* WLAN devices should always be named "wlan%d" */		if ((dev->driver_info->flags & FLAG_WLAN) != 0)			strcpy(net->name, "wlan%d");		/* WWAN devices should always be named "wwan%d" */		if ((dev->driver_info->flags & FLAG_WWAN) != 0)			strcpy(net->name, "wwan%d");		/* maybe the remote can't receive an Ethernet MTU */		if (net->mtu > (dev->hard_mtu - net->hard_header_len))			net->mtu = dev->hard_mtu - net->hard_header_len;	} else if (!info->in || !info->out)		status = usbnet_get_endpoints (dev, udev);	else {		dev->in = usb_rcvbulkpipe (xdev, info->in);		dev->out = usb_sndbulkpipe (xdev, info->out);		if (!(info->flags & FLAG_NO_SETINT))			status = usb_set_interface (xdev,				interface->desc.bInterfaceNumber,				interface->desc.bAlternateSetting);		else			status = 0;	}	if (status >= 0 && dev->status)		status = init_status (dev, udev);	if (status < 0)		goto out3;	if (!dev->rx_urb_size)		dev->rx_urb_size = dev->hard_mtu;	dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);	SET_NETDEV_DEV(net, &udev->dev);	if ((dev->driver_info->flags & FLAG_WLAN) != 0)		SET_NETDEV_DEVTYPE(net, &wlan_type);	if ((dev->driver_info->flags & FLAG_WWAN) != 0)		SET_NETDEV_DEVTYPE(net, &wwan_type);	status = register_netdev (net);	if (status)		goto out3;	netif_info(dev, probe, dev->net,		   "register '%s' at usb-%s-%s, %s, %pM/n",		   udev->dev.driver->name,		   xdev->bus->bus_name, xdev->devpath,		   dev->driver_info->description,		   net->dev_addr);	// ok, it's ready to go.	usb_set_intfdata (udev, dev);	netif_device_attach (net);	if (dev->driver_info->flags & FLAG_LINK_INTR)		netif_carrier_off(net);	return 0;out3:	if (info->unbind)		info->unbind (dev, udev);out1:	free_netdev(net);out:	usb_put_dev(xdev);	return status;}

int chunk_msg(struct usb_device *dev, unsigned long pipe, int *pid, int in,	      void *buffer, int len, bool ignore_ack){	struct dwc2_hc_regs *hc_regs = &regs->hc_regs[DWC2_HC_CHANNEL];	int devnum = usb_pipedevice(pipe);	int ep = usb_pipeendpoint(pipe);	int max = usb_maxpacket(dev, pipe);	int eptype = dwc2_eptype[usb_pipetype(pipe)];	int done = 0;	int ret = 0;	uint32_t sub;	uint32_t xfer_len;	uint32_t num_packets;	int stop_transfer = 0;	debug("%s: msg: pipe %lx pid %d in %d len %d/n", __func__, pipe, *pid,	      in, len);	do {		/* Initialize channel */		dwc_otg_hc_init(regs, DWC2_HC_CHANNEL, dev, devnum, ep, in,				eptype, max);		xfer_len = len - done;		if (xfer_len > CONFIG_DWC2_MAX_TRANSFER_SIZE)			xfer_len = CONFIG_DWC2_MAX_TRANSFER_SIZE - max + 1;		if (xfer_len > DWC2_DATA_BUF_SIZE)			xfer_len = DWC2_DATA_BUF_SIZE - max + 1;		/* Make sure that xfer_len is a multiple of max packet size. */		if (xfer_len > 0) {			num_packets = (xfer_len + max - 1) / max;			if (num_packets > CONFIG_DWC2_MAX_PACKET_COUNT) {				num_packets = CONFIG_DWC2_MAX_PACKET_COUNT;				xfer_len = num_packets * max;			}		} else {			num_packets = 1;		}		if (in)			xfer_len = num_packets * max;		debug("%s: chunk: pid %d xfer_len %u pkts %u/n", __func__,		      *pid, xfer_len, num_packets);		writel((xfer_len << DWC2_HCTSIZ_XFERSIZE_OFFSET) |		       (num_packets << DWC2_HCTSIZ_PKTCNT_OFFSET) |		       (*pid << DWC2_HCTSIZ_PID_OFFSET),		       &hc_regs->hctsiz);		if (!in)			memcpy(aligned_buffer, (char *)buffer + done, len);		writel(phys_to_bus((unsigned long)aligned_buffer),		       &hc_regs->hcdma);		/* Set host channel enable after all other setup is complete. */		clrsetbits_le32(&hc_regs->hcchar, DWC2_HCCHAR_MULTICNT_MASK |				DWC2_HCCHAR_CHEN | DWC2_HCCHAR_CHDIS,				(1 << DWC2_HCCHAR_MULTICNT_OFFSET) |				DWC2_HCCHAR_CHEN);		ret = wait_for_chhltd(&sub, pid, ignore_ack);		if (ret)			break;		if (in) {			xfer_len -= sub;			memcpy(buffer + done, aligned_buffer, xfer_len);			if (sub)				stop_transfer = 1;		}		done += xfer_len;	} while ((done < len) && !stop_transfer);	writel(0, &hc_regs->hcintmsk);	writel(0xFFFFFFFF, &hc_regs->hcint);	dev->status = 0;	dev->act_len = done;	return ret;}

void dwc_otg_hcd_qh_init(dwc_otg_hcd_t *hcd, dwc_otg_qh_t *qh, struct urb *urb){	char *speed, *type;	memset (qh, 0, sizeof (dwc_otg_qh_t));	/* Initialize QH */	switch (usb_pipetype(urb->pipe)) {	case PIPE_CONTROL:		qh->ep_type = USB_ENDPOINT_XFER_CONTROL;		break;	case PIPE_BULK:		qh->ep_type = USB_ENDPOINT_XFER_BULK;		break;	case PIPE_ISOCHRONOUS:		qh->ep_type = USB_ENDPOINT_XFER_ISOC;		break;	case PIPE_INTERRUPT:		qh->ep_type = USB_ENDPOINT_XFER_INT;		break;	}	qh->ep_is_in = usb_pipein(urb->pipe) ? 1 : 0;	qh->data_toggle = DWC_OTG_HC_PID_DATA0;	qh->maxp = usb_maxpacket(urb->dev, urb->pipe, !(usb_pipein(urb->pipe)));	INIT_LIST_HEAD(&qh->qtd_list);	INIT_LIST_HEAD(&qh->qh_list_entry);	qh->channel = NULL;	/* FS/LS Enpoint on HS Hub	 * NOT virtual root hub */	qh->do_split = 0;	if (((urb->dev->speed == USB_SPEED_LOW) ||	     (urb->dev->speed == USB_SPEED_FULL)) &&	     (urb->dev->tt) && (urb->dev->tt->hub) && (urb->dev->tt->hub->devnum != 1))	{		DWC_DEBUGPL(DBG_HCD, "QH init: EP %d: TT found at hub addr %d, for port %d/n",			   usb_pipeendpoint(urb->pipe), urb->dev->tt->hub->devnum,			   urb->dev->ttport);		qh->do_split = 1;	}	if (qh->ep_type == USB_ENDPOINT_XFER_INT ||	    qh->ep_type == USB_ENDPOINT_XFER_ISOC) {		/* Compute scheduling parameters once and save them. */		hprt0_data_t hprt;		/** @todo Account for split transfers in the bus time. */		int bytecount = dwc_hb_mult(qh->maxp) * dwc_max_packet(qh->maxp);		/* FIXME: work-around patch by Steven */		qh->usecs = NS_TO_US(usb_calc_bus_time(urb->dev->speed,					       usb_pipein(urb->pipe),					       (qh->ep_type == USB_ENDPOINT_XFER_ISOC),					       bytecount));		/* Start in a slightly future (micro)frame. */		qh->sched_frame = dwc_frame_num_inc(hcd->frame_number,						     SCHEDULE_SLOP);		qh->interval = urb->interval;#if 0		/* Increase interrupt polling rate for debugging. */		if (qh->ep_type == USB_ENDPOINT_XFER_INT) {			qh->interval = 8;		}#endif		hprt.d32 = dwc_read_reg32(hcd->core_if->host_if->hprt0);		if ((hprt.b.prtspd == DWC_HPRT0_PRTSPD_HIGH_SPEED) &&		    ((urb->dev->speed == USB_SPEED_LOW) ||		     (urb->dev->speed == USB_SPEED_FULL))) {			qh->interval *= 8;			qh->sched_frame |= 0x7;			qh->start_split_frame = qh->sched_frame;		}	}	DWC_DEBUGPL(DBG_HCD, "DWC OTG HCD QH Initialized/n");	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - qh = %p/n", qh);	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - Device Address = %d/n",		    urb->dev->devnum);	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - Endpoint %d, %s/n",		    usb_pipeendpoint(urb->pipe),		    usb_pipein(urb->pipe) == USB_DIR_IN ? "IN" : "OUT");	switch(urb->dev->speed) {	case USB_SPEED_LOW:		speed = "low";		break;	case USB_SPEED_FULL:		speed = "full";		break;	case USB_SPEED_HIGH:		speed = "high";		break;	default:		speed = "?";		break;	}	DWC_DEBUGPL(DBG_HCDV, "DWC OTG HCD QH  - Speed = %s/n", speed);//.........这里部分代码省略.........

static intehci_submit_async(struct usb_device *dev, unsigned long pipe, void *buffer,		   int length, struct devrequest *req){	struct QH *qh;	struct qTD *td;	volatile struct qTD *vtd;	unsigned long ts;	uint32_t *tdp;	uint32_t endpt, token, usbsts;	uint32_t c, toggle;	uint32_t cmd;	int timeout;	int ret = 0;	debug("dev=%p, pipe=%lx, buffer=%p, length=%d, req=%p/n", dev, pipe,	      buffer, length, req);	if (req != NULL)		debug("req=%u (%#x), type=%u (%#x), value=%u (%#x), index=%u/n",		      req->request, req->request,		      req->requesttype, req->requesttype,		      le16_to_cpu(req->value), le16_to_cpu(req->value),		      le16_to_cpu(req->index));	qh = ehci_alloc(sizeof(struct QH), 32);	if (qh == NULL) {		debug("unable to allocate QH/n");		return -1;	}	qh->qh_link = cpu_to_hc32((uint32_t)&qh_list | QH_LINK_TYPE_QH);	c = (usb_pipespeed(pipe) != USB_SPEED_HIGH &&	     usb_pipeendpoint(pipe) == 0) ? 1 : 0;	endpt = (8 << 28) |	    (c << 27) |	    (usb_maxpacket(dev, pipe) << 16) |	    (0 << 15) |	    (1 << 14) |	    (usb_pipespeed(pipe) << 12) |	    (usb_pipeendpoint(pipe) << 8) |	    (0 << 7) | (usb_pipedevice(pipe) << 0);	qh->qh_endpt1 = cpu_to_hc32(endpt);	endpt = (1 << 30) |	    (dev->portnr << 23) |	    (dev->parent->devnum << 16) | (0 << 8) | (0 << 0);	qh->qh_endpt2 = cpu_to_hc32(endpt);	qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);	td = NULL;	tdp = &qh->qh_overlay.qt_next;	toggle =	    usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));	if (req != NULL) {		td = ehci_alloc(sizeof(struct qTD), 32);		if (td == NULL) {			debug("unable to allocate SETUP td/n");			goto fail;		}		td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);		td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);		token = (0 << 31) |		    (sizeof(*req) << 16) |		    (0 << 15) | (0 << 12) | (3 << 10) | (2 << 8) | (0x80 << 0);		td->qt_token = cpu_to_hc32(token);		if (ehci_td_buffer(td, req, sizeof(*req)) != 0) {			debug("unable construct SETUP td/n");			ehci_free(td, sizeof(*td));			goto fail;		}		*tdp = cpu_to_hc32((uint32_t) td);		tdp = &td->qt_next;		toggle = 1;	}	if (length > 0 || req == NULL) {		td = ehci_alloc(sizeof(struct qTD), 32);		if (td == NULL) {			debug("unable to allocate DATA td/n");			goto fail;		}		td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);		td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);		token = (toggle << 31) |		    (length << 16) |		    ((req == NULL ? 1 : 0) << 15) |		    (0 << 12) |		    (3 << 10) |		    ((usb_pipein(pipe) ? 1 : 0) << 8) | (0x80 << 0);		td->qt_token = cpu_to_hc32(token);		if (ehci_td_buffer(td, buffer, length) != 0) {			debug("unable construct DATA td/n");			ehci_free(td, sizeof(*td));			goto fail;		}		*tdp = cpu_to_hc32((uint32_t) td);		tdp = &td->qt_next;	}	if (req != NULL) {//.........这里部分代码省略.........

/*  * 驱动程序的探测函数  */static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id){	/*  	 * 接口结构体包含于设备结构体中，interface_to_usbdev 是通过接口结构体获得它的设备结构体。 	 * usb_host_interface 是用于描述接口设置的结构体，内嵌在接口结构体 usb_interface 中。 	 * usb_endpoint_descriptor 是端点描述符结构体，内嵌在端点结构体 usb_host_endpoint 中，而端点 	 * 结构体内嵌在接口设置结构体中。 	 */	struct usb_device *dev = interface_to_usbdev(intf);	struct usb_host_interface *interface;	struct usb_endpoint_descriptor *endpoint;	struct usb_mouse *mouse;	struct input_dev *input_dev;	int pipe, maxp;	interface = intf->cur_altsetting;	/* 鼠标仅有一个 interrupt 类型的 in 端点，不满足此要求的设备均报错 */	if (interface->desc.bNumEndpoints != 1)		return -ENODEV;	endpoint = &interface->endpoint[0].desc;	if (!usb_endpoint_is_int_in(endpoint))		return -ENODEV;	/* 	 * 返回对应端点能够传输的最大的数据包，鼠标的返回的最大数据包为4个字节，数据包具体内容在 urb 	 * 回调函数中有详细说明。 	 */	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	/* 为 mouse 设备结构体分配内存 */	mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);	/* input_dev */	input_dev = input_allocate_device();	if (!mouse || !input_dev)		goto fail1;	/* 	 * 申请内存空间用于数据传输，data 为指向该空间的地址，data_dma 则是这块内存空间的 dma 映射， 	 * 即这块内存空间对应的 dma 地址。在使用 dma 传输的情况下，则使用 data_dma 指向的 dma 区域， 	 * 否则使用 data 指向的普通内存区域进行传输。 	 * GFP_ATOMIC 表示不等待，GFP_KERNEL 是普通的优先级，可以睡眠等待，由于鼠标使用中断传输方式， 	 * 不允许睡眠状态，data 又是周期性获取鼠标事件的存储区，因此使用 GFP_ATOMIC 优先级，如果不能 	 * 分配到内存则立即返回 0。 	 */	mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma);	if (!mouse->data)		goto fail1;	/* 	 * 为 urb 结构体申请内存空间，第一个参数表示等时传输时需要传送包的数量，其它传输方式则为0。 	 * 申请的内存将通过下面即将见到的 usb_fill_int_urb 函数进行填充。  	 */	mouse->irq = usb_alloc_urb(0, GFP_KERNEL);	if (!mouse->irq)		goto fail2;	/* 填充 usb 设备结构体和输入设备结构体 */	mouse->usbdev = dev;	mouse->dev = input_dev;	/* 获取鼠标设备的名称 */	if (dev->manufacturer)		strlcpy(mouse->name, dev->manufacturer, sizeof(mouse->name));	if (dev->product) {		if (dev->manufacturer)			strlcat(mouse->name, " ", sizeof(mouse->name));		strlcat(mouse->name, dev->product, sizeof(mouse->name));	}	if (!strlen(mouse->name))		snprintf(mouse->name, sizeof(mouse->name),			 "USB HIDBP Mouse %04x:%04x",			 le16_to_cpu(dev->descriptor.idVendor),			 le16_to_cpu(dev->descriptor.idProduct));	/* 	 * 填充鼠标设备结构体中的节点名。usb_make_path 用来获取 USB 设备在 Sysfs 中的路径，格式 	 * 为：usb-usb 总线号-路径名。 	 */	usb_make_path(dev, mouse->phys, sizeof(mouse->phys));	strlcat(mouse->phys, "/input0", sizeof(mouse->phys));	/* 将鼠标设备的名称赋给鼠标设备内嵌的输入子系统结构体 */	input_dev->name = mouse->name;	/* 将鼠标设备的设备节点名赋给鼠标设备内嵌的输入子系统结构体 */	input_dev->phys = mouse->phys;	/* 	 * input_dev 中的 input_id 结构体，用来存储厂商、设备类型和设备的编号，这个函数是将设备描述符 	 * 中的编号赋给内嵌的输入子系统结构体 	 */	usb_to_input_id(dev, &input_dev->id);	/* cdev 是设备所属类别（class device） */	input_dev->cdev.dev = &intf->dev;//.........这里部分代码省略.........

/* * This routine is called by the USB subsystem for each new device * in the system. We need to check if the device is ours, and in * this case start handling it. */static int kingsun_probe(struct usb_interface *intf,		      const struct usb_device_id *id){	struct usb_host_interface *interface;	struct usb_endpoint_descriptor *endpoint;	struct usb_device *dev = interface_to_usbdev(intf);	struct kingsun_cb *kingsun = NULL;	struct net_device *net = NULL;	int ret = -ENOMEM;	int pipe, maxp_in, maxp_out;	__u8 ep_in;	__u8 ep_out;	/* Check that there really are two interrupt endpoints.	   Check based on the one in drivers/usb/input/usbmouse.c	 */	interface = intf->cur_altsetting;	if (interface->desc.bNumEndpoints != 2) {		dev_err(&intf->dev,			"kingsun-sir: expected 2 endpoints, found %d/n",			interface->desc.bNumEndpoints);		return -ENODEV;	}	endpoint = &interface->endpoint[KINGSUN_EP_IN].desc;	if (!usb_endpoint_is_int_in(endpoint)) {		dev_err(&intf->dev,			"kingsun-sir: endpoint 0 is not interrupt IN/n");		return -ENODEV;	}	ep_in = endpoint->bEndpointAddress;	pipe = usb_rcvintpipe(dev, ep_in);	maxp_in = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	if (maxp_in > 255 || maxp_in <= 1) {		dev_err(&intf->dev,			"endpoint 0 has max packet size %d not in range/n",			maxp_in);		return -ENODEV;	}	endpoint = &interface->endpoint[KINGSUN_EP_OUT].desc;	if (!usb_endpoint_is_int_out(endpoint)) {		dev_err(&intf->dev,			"kingsun-sir: endpoint 1 is not interrupt OUT/n");		return -ENODEV;	}	ep_out = endpoint->bEndpointAddress;	pipe = usb_sndintpipe(dev, ep_out);	maxp_out = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	/* Allocate network device container. */	net = alloc_irdadev(sizeof(*kingsun));	if(!net)		goto err_out1;	SET_NETDEV_DEV(net, &intf->dev);	kingsun = netdev_priv(net);	kingsun->irlap = NULL;	kingsun->tx_urb = NULL;	kingsun->rx_urb = NULL;	kingsun->ep_in = ep_in;	kingsun->ep_out = ep_out;	kingsun->in_buf = NULL;	kingsun->out_buf = NULL;	kingsun->max_rx = (__u8)maxp_in;	kingsun->max_tx = (__u8)maxp_out;	kingsun->netdev = net;	kingsun->usbdev = dev;	kingsun->rx_buff.in_frame = FALSE;	kingsun->rx_buff.state = OUTSIDE_FRAME;	kingsun->rx_buff.skb = NULL;	kingsun->receiving = 0;	spin_lock_init(&kingsun->lock);	/* Allocate input buffer */	kingsun->in_buf = kmalloc(kingsun->max_rx, GFP_KERNEL);	if (!kingsun->in_buf)		goto free_mem;	/* Allocate output buffer */	kingsun->out_buf = kmalloc(KINGSUN_FIFO_SIZE, GFP_KERNEL);	if (!kingsun->out_buf)		goto free_mem;	printk(KERN_INFO "KingSun/DonShine IRDA/USB found at address %d, "		"Vendor: %x, Product: %x/n",	       dev->devnum, le16_to_cpu(dev->descriptor.idVendor),	       le16_to_cpu(dev->descriptor.idProduct));	/* Initialize QoS for this device */	irda_init_max_qos_capabilies(&kingsun->qos);	/* That's the Rx capability. *///.........这里部分代码省略.........

int onetouch_connect_input(struct us_data *ss){	struct usb_device *udev = ss->pusb_dev;	struct usb_host_interface *interface;	struct usb_endpoint_descriptor *endpoint;	struct usb_onetouch *onetouch;	struct input_dev *input_dev;	int pipe, maxp;	int error = -ENOMEM;	interface = ss->pusb_intf->cur_altsetting;	if (interface->desc.bNumEndpoints != 3)		return -ENODEV;	endpoint = &interface->endpoint[2].desc;	if (!usb_endpoint_is_int_in(endpoint))		return -ENODEV;	pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);	maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));	onetouch = kzalloc(sizeof(struct usb_onetouch), GFP_KERNEL);	input_dev = input_allocate_device();	if (!onetouch || !input_dev)		goto fail1;	onetouch->data = usb_buffer_alloc(udev, ONETOUCH_PKT_LEN,					  GFP_ATOMIC, &onetouch->data_dma);	if (!onetouch->data)		goto fail1;	onetouch->irq = usb_alloc_urb(0, GFP_KERNEL);	if (!onetouch->irq)		goto fail2;	onetouch->udev = udev;	onetouch->dev = input_dev;	if (udev->manufacturer)		strlcpy(onetouch->name, udev->manufacturer,			sizeof(onetouch->name));	if (udev->product) {		if (udev->manufacturer)			strlcat(onetouch->name, " ", sizeof(onetouch->name));		strlcat(onetouch->name, udev->product, sizeof(onetouch->name));	}	if (!strlen(onetouch->name))		snprintf(onetouch->name, sizeof(onetouch->name),			 "Maxtor Onetouch %04x:%04x",			 le16_to_cpu(udev->descriptor.idVendor),			 le16_to_cpu(udev->descriptor.idProduct));	usb_make_path(udev, onetouch->phys, sizeof(onetouch->phys));	strlcat(onetouch->phys, "/input0", sizeof(onetouch->phys));	input_dev->name = onetouch->name;	input_dev->phys = onetouch->phys;	usb_to_input_id(udev, &input_dev->id);	input_dev->dev.parent = &udev->dev;	set_bit(EV_KEY, input_dev->evbit);	set_bit(ONETOUCH_BUTTON, input_dev->keybit);	clear_bit(0, input_dev->keybit);	input_set_drvdata(input_dev, onetouch);	input_dev->open = usb_onetouch_open;	input_dev->close = usb_onetouch_close;	usb_fill_int_urb(onetouch->irq, udev, pipe, onetouch->data,			 (maxp > 8 ? 8 : maxp),			 usb_onetouch_irq, onetouch, endpoint->bInterval);	onetouch->irq->transfer_dma = onetouch->data_dma;	onetouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	ss->extra_destructor = onetouch_release_input;	ss->extra = onetouch;#ifdef CONFIG_PM	ss->suspend_resume_hook = usb_onetouch_pm_hook;#endif	error = input_register_device(onetouch->dev);	if (error)		goto fail3;	return 0; fail3:	usb_free_urb(onetouch->irq); fail2:	usb_buffer_free(udev, ONETOUCH_PKT_LEN,			onetouch->data, onetouch->data_dma); fail1:	kfree(onetouch);	input_free_device(input_dev);	return error;}

intgeneric_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags){    int			retval;    struct net_device	*net = dev->net;    struct cdc_state	*info = (void *) &dev->data;    union {        void			*buf;        struct rndis_msg_hdr	*header;        struct rndis_init	*init;        struct rndis_init_c	*init_c;        struct rndis_query	*get;        struct rndis_query_c	*get_c;        struct rndis_set	*set;        struct rndis_set_c	*set_c;        struct rndis_halt	*halt;    } u;    u32			tmp;    __le32			phym_unspec, *phym;    int			reply_len;    unsigned char		*bp;    /* we can't rely on i/o from stack working, or stack allocation */    u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);    if (!u.buf)        return -ENOMEM;    retval = usbnet_generic_cdc_bind(dev, intf);    if (retval < 0)        goto fail;    u.init->msg_type = cpu_to_le32(RNDIS_MSG_INIT);    u.init->msg_len = cpu_to_le32(sizeof *u.init);    u.init->major_version = cpu_to_le32(1);    u.init->minor_version = cpu_to_le32(0);#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29))    /* can't we remove this? */    net->change_mtu = NULL;#endif    /* max transfer (in spec) is 0x4000 at full speed, but for     * TX we'll stick to one Ethernet packet plus RNDIS framing.     * For RX we handle drivers that zero-pad to end-of-packet.     * Don't let userspace change these settings.     *     * NOTE: there still seems to be wierdness here, as if we need     * to do some more things to make sure WinCE targets accept this.     * They default to jumbograms of 8KB or 16KB, which is absurd     * for such low data rates and which is also more than Linux     * can usually expect to allocate for SKB data...     */    net->hard_header_len += sizeof (struct rndis_data_hdr);    dev->hard_mtu = net->mtu + net->hard_header_len;    dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);    if (dev->maxpacket == 0) {        netif_dbg(dev, probe, dev->net,                  "dev->maxpacket can't be 0/n");        retval = -EINVAL;        goto fail_and_release;    }    dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);    dev->rx_urb_size &= ~(dev->maxpacket - 1);    u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);    netdev_attach_ops(net, &rndis_netdev_ops);    retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);    if (unlikely(retval < 0)) {        /* it might not even be an RNDIS device!! */        dev_err(&intf->dev, "RNDIS init failed, %d/n", retval);        goto fail_and_release;    }    tmp = le32_to_cpu(u.init_c->max_transfer_size);    if (tmp < dev->hard_mtu) {        if (tmp <= net->hard_header_len) {            dev_err(&intf->dev,                    "dev can't take %u byte packets (max %u)/n",                    dev->hard_mtu, tmp);            retval = -EINVAL;            goto halt_fail_and_release;        }        dev_warn(&intf->dev,                 "dev can't take %u byte packets (max %u), "                 "adjusting MTU to %u/n",                 dev->hard_mtu, tmp, tmp - net->hard_header_len);        dev->hard_mtu = tmp;        net->mtu = dev->hard_mtu - net->hard_header_len;    }    /* REVISIT:  peripheral "alignment" request is ignored ... */    dev_dbg(&intf->dev,            "hard mtu %u (%u from dev), rx buflen %Zu, align %d/n",            dev->hard_mtu, tmp, dev->rx_urb_size,            1 << le32_to_cpu(u.init_c->packet_alignment));    /* module has some device initialization code needs to be done right     * after RNDIS_INIT */    if (dev->driver_info->early_init &&//.........这里部分代码省略.........

static int igorplugusb_remote_probe(struct usb_interface *intf,				    const struct usb_device_id *id){	struct usb_device *dev;	struct usb_host_interface *idesc = NULL;	struct usb_endpoint_descriptor *ep;	struct igorplug *ir = NULL;	struct lirc_driver *driver = NULL;	int devnum, pipe, maxp;	char buf[63], name[128] = "";	int ret;	dprintk(DRIVER_NAME ": usb probe called./n");	dev = interface_to_usbdev(intf);	idesc = intf->cur_altsetting;	if (idesc->desc.bNumEndpoints != 1)		return -ENODEV;	ep = &idesc->endpoint->desc;	if (((ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)	    != USB_DIR_IN)	    || (ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)	    != USB_ENDPOINT_XFER_CONTROL)		return -ENODEV;	pipe = usb_rcvctrlpipe(dev, ep->bEndpointAddress);	devnum = dev->devnum;	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d/n",		devnum, CODE_LENGTH, maxp);	ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);	if (!ir)		return -ENOMEM;	driver = devm_kzalloc(&intf->dev, sizeof(*driver), GFP_KERNEL);	if (!driver)		return -ENOMEM;	ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,					GFP_ATOMIC, &ir->dma_in);	if (!ir->buf_in)		return -ENOMEM;	strcpy(driver->name, DRIVER_NAME " ");	driver->minor = -1;	driver->code_length = CODE_LENGTH * 8; /* in bits */	driver->features = LIRC_CAN_REC_MODE2;	driver->data = ir;	driver->chunk_size = CODE_LENGTH;	driver->buffer_size = DEVICE_BUFLEN + ADDITIONAL_LIRC_BYTES;	driver->set_use_inc = &set_use_inc;	driver->set_use_dec = &set_use_dec;	driver->sample_rate = sample_rate;    /* per second */	driver->add_to_buf = &igorplugusb_remote_poll;	driver->dev = &intf->dev;	driver->owner = THIS_MODULE;	ret = lirc_register_driver(driver);	if (ret < 0) {		usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,			ir->buf_in, ir->dma_in);		return ret;	}	driver->minor = ret;	ir->d = driver;	ir->devnum = devnum;	ir->usbdev = dev;	ir->len_in = DEVICE_BUFLEN + DEVICE_HEADERLEN;	ir->in_space = 1; /* First mode2 event is a space. */	do_gettimeofday(&ir->last_time);	if (dev->descriptor.iManufacturer	    && usb_string(dev, dev->descriptor.iManufacturer,			  buf, sizeof(buf)) > 0)		strlcpy(name, buf, sizeof(name));	if (dev->descriptor.iProduct	    && usb_string(dev, dev->descriptor.iProduct, buf, sizeof(buf)) > 0)		snprintf(name + strlen(name), sizeof(name) - strlen(name),			 " %s", buf);	printk(DRIVER_NAME "[%d]: %s on usb%d:%d/n", devnum, name,	       dev->bus->busnum, devnum);	/* clear device buffer */	ret = usb_control_msg(ir->usbdev, usb_rcvctrlpipe(ir->usbdev, 0),		SET_INFRABUFFER_EMPTY, USB_TYPE_VENDOR|USB_DIR_IN,		/*unused*/0, /*unused*/0,		/*dummy*/ir->buf_in, /*dummy*/ir->len_in,		/*timeout*/HZ * USB_CTRL_GET_TIMEOUT);	if (ret < 0)		printk(DRIVER_NAME "[%d]: SET_INFRABUFFER_EMPTY: error %d/n",			devnum, ret);	usb_set_intfdata(intf, ir);	return 0;//.........这里部分代码省略.........

static int us_one_transfer(struct us_data *us, int pipe, char *buf, int length){    int max_size;    int this_xfer;    int result;    int partial;    int maxtry;    int stat;    /* determine the maximum packet size for these transfers */    max_size = usb_maxpacket(us->pusb_dev, pipe) * 16;    /* while we have data left to transfer */    while (length) {        /* calculate how long this will be -- maximum or a remainder */        this_xfer = length > max_size ? max_size : length;        length -= this_xfer;        /* setup the retry counter */        maxtry = 10;        /* set up the transfer loop */        do {            /* transfer the data */            USB_STOR_PRINTF("Bulk xfer 0x%x(%d) try #%d/n",                            (unsigned int)buf, this_xfer, 11 - maxtry);            result = usb_bulk_msg(us->pusb_dev, pipe, buf,                                  this_xfer, &partial, USB_CNTL_TIMEOUT*5);            USB_STOR_PRINTF("bulk_msg returned %d xferred %d/%d/n",                            result, partial, this_xfer);            if(us->pusb_dev->status!=0) {                /* if we stall, we need to clear it before we go on */#ifdef USB_STOR_DEBUG                display_int_status(us->pusb_dev->status);#endif                if (us->pusb_dev->status & USB_ST_STALLED) {                    USB_STOR_PRINTF("stalled ->clearing endpoint halt for pipe 0x%x/n", pipe);                    stat = us->pusb_dev->status;                    usb_clear_halt(us->pusb_dev, pipe);                    us->pusb_dev->status=stat;                    if(this_xfer == partial) {                        USB_STOR_PRINTF("bulk transferred with error %X, but data ok/n",us->pusb_dev->status);                        return 0;                    }                    else                        return result;                }                if (us->pusb_dev->status & USB_ST_NAK_REC) {                    USB_STOR_PRINTF("Device NAKed bulk_msg/n");                    return result;                }                if(this_xfer == partial) {                    USB_STOR_PRINTF("bulk transferred with error %d, but data ok/n",us->pusb_dev->status);                    return 0;                }                /* if our try counter reaches 0, bail out */                USB_STOR_PRINTF("bulk transferred with error %d, data %d/n",us->pusb_dev->status,partial);                if (!maxtry--)                    return result;            }            /* update to show what data was transferred */            this_xfer -= partial;            buf += partial;            /* continue until this transfer is done */        } while ( this_xfer );    }    /* if we get here, we're done and successful */    return 0;}

/*	Create and register the PCM device and mixer entries.	Create URBs for playback and capture.*/int line6_init_pcm(struct usb_line6 *line6,		   struct line6_pcm_properties *properties){	static struct snd_device_ops pcm_ops = {		.dev_free = snd_line6_pcm_free,	};	int err;	int ep_read = 0, ep_write = 0;	struct snd_line6_pcm *line6pcm;	if (!(line6->properties->capabilities & LINE6_BIT_PCM))		return 0;	/* skip PCM initialization and report success */	/* initialize PCM subsystem based on product id: */	switch (line6->product) {	case LINE6_DEVID_BASSPODXT:	case LINE6_DEVID_BASSPODXTLIVE:	case LINE6_DEVID_BASSPODXTPRO:	case LINE6_DEVID_PODXT:	case LINE6_DEVID_PODXTLIVE:	case LINE6_DEVID_PODXTPRO:	case LINE6_DEVID_PODHD300:		ep_read = 0x82;		ep_write = 0x01;		break;	case LINE6_DEVID_PODHD500:	case LINE6_DEVID_PODX3:	case LINE6_DEVID_PODX3LIVE:		ep_read = 0x86;		ep_write = 0x02;		break;	case LINE6_DEVID_POCKETPOD:		ep_read = 0x82;		ep_write = 0x02;		break;	case LINE6_DEVID_GUITARPORT:	case LINE6_DEVID_PODSTUDIO_GX:	case LINE6_DEVID_PODSTUDIO_UX1:	case LINE6_DEVID_PODSTUDIO_UX2:	case LINE6_DEVID_TONEPORT_GX:	case LINE6_DEVID_TONEPORT_UX1:	case LINE6_DEVID_TONEPORT_UX2:		ep_read = 0x82;		ep_write = 0x01;		break;		/* this is for interface_number == 1:		   case LINE6_DEVID_TONEPORT_UX2:		   case LINE6_DEVID_PODSTUDIO_UX2:		   ep_read  = 0x87;		   ep_write = 0x00;		   break;		 */	default:		MISSING_CASE;	}	line6pcm = kzalloc(sizeof(struct snd_line6_pcm), GFP_KERNEL);	if (line6pcm == NULL)		return -ENOMEM;	line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255;	line6pcm->volume_monitor = 255;	line6pcm->line6 = line6;	line6pcm->ep_audio_read = ep_read;	line6pcm->ep_audio_write = ep_write;	/* Read and write buffers are sized identically, so choose minimum */	line6pcm->max_packet_size = min(			usb_maxpacket(line6->usbdev,				usb_rcvisocpipe(line6->usbdev, ep_read), 0),			usb_maxpacket(line6->usbdev,				usb_sndisocpipe(line6->usbdev, ep_write), 1));	line6pcm->properties = properties;	line6->line6pcm = line6pcm;	/* PCM device: */	err = snd_device_new(line6->card, SNDRV_DEV_PCM, line6, &pcm_ops);	if (err < 0)		return err;	snd_card_set_dev(line6->card, line6->ifcdev);	err = snd_line6_new_pcm(line6pcm);	if (err < 0)		return err;	spin_lock_init(&line6pcm->lock_audio_out);	spin_lock_init(&line6pcm->lock_audio_in);//.........这里部分代码省略.........

static int rndis_bind(struct usbnet *dev, struct usb_interface *intf){	int			retval;	struct net_device	*net = dev->net;	struct cdc_state	*info = (void *) &dev->data;	union {		void			*buf;		struct rndis_msg_hdr	*header;		struct rndis_init	*init;		struct rndis_init_c	*init_c;		struct rndis_query	*get;		struct rndis_query_c	*get_c;		struct rndis_set	*set;		struct rndis_set_c	*set_c;	} u;	u32			tmp;	int			reply_len;	unsigned char		*bp;	/* we can't rely on i/o from stack working, or stack allocation */	u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);	if (!u.buf)		return -ENOMEM;	retval = usbnet_generic_cdc_bind(dev, intf);	if (retval < 0)		goto fail;	u.init->msg_type = RNDIS_MSG_INIT;	u.init->msg_len = ccpu2(sizeof *u.init);	u.init->major_version = ccpu2(1);	u.init->minor_version = ccpu2(0);	/* max transfer (in spec) is 0x4000 at full speed, but for	 * TX we'll stick to one Ethernet packet plus RNDIS framing.	 * For RX we handle drivers that zero-pad to end-of-packet.	 * Don't let userspace change these settings.	 *	 * NOTE: there still seems to be wierdness here, as if we need	 * to do some more things to make sure WinCE targets accept this.	 * They default to jumbograms of 8KB or 16KB, which is absurd	 * for such low data rates and which is also more than Linux	 * can usually expect to allocate for SKB data...	 */	net->hard_header_len += sizeof (struct rndis_data_hdr);	dev->hard_mtu = net->mtu + net->hard_header_len;        dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);        if (dev->maxpacket == 0) {                if (netif_msg_probe(dev))                        dev_dbg(&intf->dev, "dev->maxpacket can't be 0/n");                retval = -EINVAL;                goto fail_and_release;        }	dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);	dev->rx_urb_size &= ~(dev->maxpacket - 1);	u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);	net->change_mtu = NULL;	retval = rndis_command(dev, u.header);	if (unlikely(retval < 0)) {		/* it might not even be an RNDIS device!! */		dev_err(&intf->dev, "RNDIS init failed, %d/n", retval);		goto fail_and_release;	}	tmp = le32_to_cpu(u.init_c->max_transfer_size);	if (tmp < dev->hard_mtu) {		dev_err(&intf->dev,			"dev can't take %u byte packets (max %u)/n",			dev->hard_mtu, tmp);		retval = -EINVAL;		goto fail_and_release;	}	/* REVISIT:  peripheral "alignment" request is ignored ... */	dev_dbg(&intf->dev,		"hard mtu %u (%u from dev), rx buflen %Zu, align %d/n",		dev->hard_mtu, tmp, dev->rx_urb_size,		1 << le32_to_cpu(u.init_c->packet_alignment));	/* Get designated host ethernet address */	reply_len = ETH_ALEN;	retval = rndis_query(dev, intf, u.buf, OID_802_3_PERMANENT_ADDRESS,			48, (void **) &bp, &reply_len);	if (unlikely(retval< 0)) {		dev_err(&intf->dev, "rndis get ethaddr, %d/n", retval);		goto fail_and_release;	}	memcpy(net->dev_addr, bp, ETH_ALEN);	/* set a nonzero filter to enable data transfers */	memset(u.set, 0, sizeof *u.set);	u.set->msg_type = RNDIS_MSG_SET;	u.set->msg_len = ccpu2(4 + sizeof *u.set);	u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;	u.set->len = ccpu2(4);	u.set->offset = ccpu2((sizeof *u.set) - 8);	*(__le32 *)(u.buf + sizeof *u.set) = ccpu2(DEFAULT_FILTER);	retval = rndis_command(dev, u.header);//.........这里部分代码省略.........

//.........这里部分代码省略.........		case 0x08:			dbg("individual port over-current protection");			break;		case 0x10:		case 0x18:			dbg("no over-current protection");                        break;	}	switch (dev->descriptor.bDeviceProtocol) {		case 0:			break;		case 1:			dbg("Single TT");			hub->tt.hub = dev;			break;		case 2:			dbg("TT per port");			hub->tt.hub = dev;			hub->tt.multi = 1;			break;		default:			dbg("Unrecognized hub protocol %d",				dev->descriptor.bDeviceProtocol);			break;	}	switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {		case 0x00:			if (dev->descriptor.bDeviceProtocol != 0)				dbg("TT requires at most 8 FS bit times");			break;		case 0x20:			dbg("TT requires at most 16 FS bit times");			break;		case 0x40:			dbg("TT requires at most 24 FS bit times");			break;		case 0x60:			dbg("TT requires at most 32 FS bit times");			break;	}	dbg("Port indicators are %s supported", 	    (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) ? "" : "not");	dbg("power on to power good time: %dms", hub->descriptor->bPwrOn2PwrGood * 2);	dbg("hub controller current requirement: %dmA", hub->descriptor->bHubContrCurrent);	for (i = 0; i < dev->maxchild; i++)		portstr[i] = hub->descriptor->DeviceRemovable[((i + 1) / 8)] & (1 << ((i + 1) % 8)) ? 'F' : 'R';	portstr[dev->maxchild] = 0;	dbg("port removable status: %s", portstr);	ret = usb_get_hub_status(dev, &hubstatus);	if (ret < 0) {		err("Unable to get hub status (err = %d)", ret);		kfree(hub->descriptor);		return -1;	}	le16_to_cpus(&hubstatus.wHubStatus);	dbg("local power source is %s",		(hubstatus.wHubStatus & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");	dbg("%sover-current condition exists",		(hubstatus.wHubStatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");	/* Start the interrupt endpoint */	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	if (maxp > sizeof(hub->buffer))		maxp = sizeof(hub->buffer);	hub->urb = usb_alloc_urb(0);	if (!hub->urb) {		err("couldn't allocate interrupt urb");		kfree(hub->descriptor);		return -1;	}	FILL_INT_URB(hub->urb, dev, pipe, hub->buffer, maxp, hub_irq,		hub, endpoint->bInterval);	ret = usb_submit_urb(hub->urb);	if (ret) {		err("usb_submit_urb failed (%d)", ret);		kfree(hub->descriptor);		return -1;	}			/* Wake up khubd */	wake_up(&khubd_wait);	usb_hub_power_on(hub);	return 0;}

//.........这里部分代码省略.........		 */		qtd_count += 2 + length / xfr_sz;	}/* * Threshold value based on the worst-case total size of the allocated qTDs for * a mass-storage transfer of 65535 blocks of 512 bytes. */#if CONFIG_SYS_MALLOC_LEN <= 64 + 128 * 1024#warning CONFIG_SYS_MALLOC_LEN may be too small for EHCI#endif	qtd = memalign(USB_DMA_MINALIGN, qtd_count * sizeof(struct qTD));	if (qtd == NULL) {		printf("unable to allocate TDs/n");		return -1;	}	memset(qh, 0, sizeof(struct QH));	memset(qtd, 0, qtd_count * sizeof(*qtd));	toggle = usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));	/*	 * Setup QH (3.6 in ehci-r10.pdf)	 *	 *   qh_link ................. 03-00 H	 *   qh_endpt1 ............... 07-04 H	 *   qh_endpt2 ............... 0B-08 H	 * - qh_curtd	 *   qh_overlay.qt_next ...... 13-10 H	 * - qh_overlay.qt_altnext	 */	qh->qh_link = cpu_to_hc32((unsigned long)&ctrl->qh_list | QH_LINK_TYPE_QH);	c = (dev->speed != USB_SPEED_HIGH) && !usb_pipeendpoint(pipe);	maxpacket = usb_maxpacket(dev, pipe);	endpt = QH_ENDPT1_RL(8) | QH_ENDPT1_C(c) |		QH_ENDPT1_MAXPKTLEN(maxpacket) | QH_ENDPT1_H(0) |		QH_ENDPT1_DTC(QH_ENDPT1_DTC_DT_FROM_QTD) |		QH_ENDPT1_EPS(ehci_encode_speed(dev->speed)) |		QH_ENDPT1_ENDPT(usb_pipeendpoint(pipe)) | QH_ENDPT1_I(0) |		QH_ENDPT1_DEVADDR(usb_pipedevice(pipe));	qh->qh_endpt1 = cpu_to_hc32(endpt);	endpt = QH_ENDPT2_MULT(1) | QH_ENDPT2_UFCMASK(0) | QH_ENDPT2_UFSMASK(0);	qh->qh_endpt2 = cpu_to_hc32(endpt);	ehci_update_endpt2_dev_n_port(dev, qh);	qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);	qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);	tdp = &qh->qh_overlay.qt_next;	if (req != NULL) {		/*		 * Setup request qTD (3.5 in ehci-r10.pdf)		 *		 *   qt_next ................ 03-00 H		 *   qt_altnext ............. 07-04 H		 *   qt_token ............... 0B-08 H		 *		 *   [ buffer, buffer_hi ] loaded with "req".		 */		qtd[qtd_counter].qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);		qtd[qtd_counter].qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);		token = QT_TOKEN_DT(0) | QT_TOKEN_TOTALBYTES(sizeof(*req)) |			QT_TOKEN_IOC(0) | QT_TOKEN_CPAGE(0) | QT_TOKEN_CERR(3) |			QT_TOKEN_PID(QT_TOKEN_PID_SETUP) |			QT_TOKEN_STATUS(QT_TOKEN_STATUS_ACTIVE);		qtd[qtd_counter].qt_token = cpu_to_hc32(token);

//.........这里部分代码省略.........	if (dma_supported(&udev->dev, DMA_BIT_MASK(64)))		net->features |= NETIF_F_HIGHDMA;#endif#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 30)	net->open		= axusbnet_open,	net->stop		= axusbnet_stop,	net->hard_start_xmit	= axusbnet_start_xmit,	net->tx_timeout	= axusbnet_tx_timeout,	net->get_stats = axusbnet_get_stats;#endif	net->watchdog_timeo = TX_TIMEOUT_JIFFIES;	net->ethtool_ops = &axusbnet_ethtool_ops;	/* allow device-specific bind/init procedures */	/* NOTE net->name still not usable ... */	status = info->bind(dev, udev);	if (status < 0) {		deverr(dev, "Binding device failed: %d", status);		goto out1;	}	/* maybe the remote can't receive an Ethernet MTU */	if (net->mtu > (dev->hard_mtu - net->hard_header_len))		net->mtu = dev->hard_mtu - net->hard_header_len;	status = init_status(dev, udev);	if (status < 0)		goto out3;	if (!dev->rx_urb_size)		dev->rx_urb_size = dev->hard_mtu;	dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);	SET_NETDEV_DEV(net, &udev->dev);	status = register_netdev(net);	if (status) {		deverr(dev, "net device registration failed: %d", status);		goto out3;	}	if (netif_msg_probe(dev))		devinfo(dev, "register '%s' at usb-%s-%s, %s, %pM",			udev->dev.driver->name,			xdev->bus->bus_name, xdev->devpath,			dev->driver_info->description,			net->dev_addr);	/* ok, it's ready to go. */	usb_set_intfdata(udev, dev);	/* start as if the link is up */	netif_device_attach(net);	return 0;out3:	if (info->unbind)		info->unbind(dev, udev);out1:	free_netdev(net);out:	usb_put_dev(xdev);	return status;}

int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,		       int len,struct devrequest *setup){	int done = 0;	int devnum = usb_pipedevice(pipe);	int ep = usb_pipeendpoint(pipe);	dev->status = 0;	if (devnum == root_hub_devnum)		return sl811_rh_submit_urb(dev, pipe, buffer, len, setup);	PDEBUG(7, "dev = %d pipe = %ld buf = %p size = %d rt = %#x req = %#x bus = %i/n",	       devnum, ep, buffer, len, (int)setup->requesttype,	       (int)setup->request, sl811_read(SL811_SOFCNTDIV)*64);	sl811_write(SL811_DEV_A, devnum);	sl811_write(SL811_PIDEP_A, PIDEP(USB_PID_SETUP, ep));	/* setup phase */	usb_settoggle(dev, ep, 1, 0);	if (sl811_send_packet(dev, usb_sndctrlpipe(dev, ep),			      (__u8*)setup, sizeof(*setup)) == sizeof(*setup)) {		int dir_in = usb_pipein(pipe);		int max = usb_maxpacket(dev, pipe);		/* data phase */		sl811_write(SL811_PIDEP_A,			    PIDEP(dir_in ? USB_PID_IN : USB_PID_OUT, ep));		usb_settoggle(dev, ep, usb_pipeout(pipe), 1);		while (done < len) {			int res = sl811_send_packet(dev, pipe, (__u8*)buffer+done,						    max > len - done ? len - done : max);			if (res < 0) {				PDEBUG(0, "status data failed!/n");				dev->status = -res;				return 0;			}			done += res;			usb_dotoggle(dev, ep, usb_pipeout(pipe));			if (dir_in && res < max) /* short packet */				break;		}		/* status phase */		sl811_write(SL811_PIDEP_A,			    PIDEP(!dir_in ? USB_PID_IN : USB_PID_OUT, ep));		usb_settoggle(dev, ep, !usb_pipeout(pipe), 1);		if (sl811_send_packet(dev,				      !dir_in ? usb_rcvctrlpipe(dev, ep) :				      usb_sndctrlpipe(dev, ep),				      0, 0) < 0) {			PDEBUG(0, "status phase failed!/n");			dev->status = -1;		}	} else {		PDEBUG(0, "setup phase failed!/n");		dev->status = -1;	}	dev->act_len = done;	return done;}