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

//.........这里部分代码省略.........		}	}	spin_lock_irq(&dev->err_lock);	retval = dev->errors;	if (retval < 0) {		/* any error is reported once */		dev->errors = 0;		/* to preserve notifications about reset */		retval = (retval == -EPIPE) ? retval : -EIO;	}	spin_unlock_irq(&dev->err_lock);	if (retval < 0)		goto error;	/* create a urb, and a buffer for it, and copy the data to the urb */	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		retval = -ENOMEM;		goto error;	}	/*	buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,				 &urb->transfer_dma);	*/	buf = kmalloc(LCD_COMMAND_SIZE, GFP_KERNEL);	if (!buf) {		retval = -ENOMEM;		goto error;	}	cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);	if (!cr) {		retval = -ENOMEM;		goto error;	}	for (i=0; i<LCD_COMMAND_SIZE; i++)		buf[i] = 0x11;	if (copy_from_user(buf, user_buffer, writesize)) {		retval = -EFAULT;		goto error;	}	/* this lock makes sure we don't submit URBs to gone devices */	mutex_lock(&dev->io_mutex);	if (!dev->interface) {		/* disconnect() was called */		mutex_unlock(&dev->io_mutex);		retval = -ENODEV;		goto error;	}	cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE;	cr->bRequest = 0x09;	cr->wValue = cpu_to_le16(0x300);	cr->wIndex = cpu_to_le16(dev->interface->cur_altsetting->desc.bInterfaceNumber);	cr->wLength = cpu_to_le16(LCD_COMMAND_SIZE);	/* initialize the urb properly */	/*	usb_fill_bulk_urb(urb, dev->udev,			  usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),			  buf, writesize, ikalcd_write_bulk_callback, dev);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	*/	usb_fill_control_urb(urb, dev->udev, usb_sndctrlpipe(dev->udev, 0),			     (unsigned char*)cr, (void*)buf, LCD_COMMAND_SIZE,			     ikalcd_write_control_callback, dev);	usb_anchor_urb(urb, &dev->submitted);	/* send the data out the bulk port */	retval = usb_submit_urb(urb, GFP_KERNEL);	mutex_unlock(&dev->io_mutex);	if (retval) {		dev_err(&dev->interface->dev,			"%s - failed submitting write urb, error %d/n",			__func__, retval);		goto error_unanchor;	}	/*	 * release our reference to this urb, the USB core will eventually free	 * it entirely	 */	usb_free_urb(urb);	return writesize;error_unanchor:	usb_unanchor_urb(urb);error:	if (urb) {		usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);		usb_free_urb(urb);	}	up(&dev->limit_sem);exit:	return retval;}

//.........这里部分代码省略.........    }    //usb_alloc_coherent (struct usb_device *dev,size_t size,gfp_t mem_flags,dma_addr_t *dma)--allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP     //分配DMA接口的缓冲区 返回 idata_dma  和 idata（raw packet，原始数据包）    xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,                                     GFP_KERNEL, &xpad->idata_dma);    if (!xpad->idata) //返回raw packet（原始数据包）失败    {        error = -ENOMEM;        goto fail1;    }    //usb_alloc_urb (int iso_packets,gfp_t mem_flags)  create a new urb for a USB driver to use   iso_packets = 0 when use interrupt endpoints    //创建新的urb给设备使用    xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);    if (!xpad->irq_in) //urb创建失败    {        error = -ENOMEM;        goto fail2;    }    xpad->udev = udev; //保存usb设备信息    xpad->intf = intf; //保存usb接口信息    xpad->dev = input_dev;  //保存输入设备信息    //创建物理路径    usb_make_path(udev, xpad->phys, sizeof(xpad->phys));    strlcat(xpad->phys, "/input0", sizeof(xpad->phys)); //input0类型的    input_dev->name = xpad_device[i].name; //保存输入设备名字    input_dev->phys = xpad->phys; //保存输入设备的物理路径    usb_to_input_id(udev, &input_dev->id); //保存输入设备ID    input_dev->dev.parent = &intf->dev; //保存输入设备的设备 输入设备的父亲是usb接口 ， usb接口的父亲 usb设备    input_set_drvdata(input_dev, xpad);    input_dev->open = xpad_open; //输入设备的打开函数    input_dev->close = xpad_close; //输入设备的关闭函数	//BIT_MASK(nr)  (1UL<<((nr)%BITS_PER_LONG）)    input_dev->evbit[0] = BIT_MASK(EV_KEY);  //注册键盘事件    input_dev->evbit[0] |= BIT_MASK(EV_REL); //注册相对轴事件    input_dev->evbit[0] |= BIT_MASK(EV_ABS); //注册绝对轴事件    /* set up axes */    for (i = 0; xpad_abs[i] >= 0; i++) ///注册对应的绝对轴        xpad_set_up_abs(input_dev, xpad_abs[i]);    xpad_set_up_rel(input_dev, REL_WHEEL); //注册对应的相对轴    for (i = 0 ; key_need_register[i] >= 0; i++) __set_bit(key_need_register[i], input_dev->keybit);    //注册按键    for (i = 0; xpad_common_btn[i] >= 0; i++)        __set_bit(xpad_common_btn[i], input_dev->keybit);    //注册游戏手柄按键    for (i = 0; xpad360_btn[i] >= 0; i++)        __set_bit(xpad360_btn[i], input_dev->keybit);        //注册LT RT按键    for (i = 0; xpad_abs_triggers[i] >= 0; i++)        xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);    //初始化设备输出    error = xpad_init_output(intf, xpad);    if (error)        goto fail3;    ep_irq_in_idx =   0;    ep_irq_in = &intf->cur_altsetting->endpoint[ep_irq_in_idx].desc; //根据usb接口得到 in endpoint口的描述信息    //函数结构 usb_fill_int_urb(struct urb* urb,struct  usb_device * dev,unsigned int pipe,void * transfer_buffer,int  buffer_length,usb_complete_t complete,void * context,int interval)    //根据 usb设备，usb管道，输入缓冲区的首地址，缓冲区长度，urb入口函数，手柄设备数据信息，in endpoint口的轮换间隔信息 得到 输入的urb    usb_fill_int_urb(xpad->irq_in, udev,                     usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),                     xpad->idata, XPAD_PKT_LEN, xpad_irq_in,                     xpad, ep_irq_in->bInterval);    xpad->irq_in->transfer_dma = xpad->idata_dma; //传输的DMA接口地址    xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; //传输标志(允许DMA方式传输) urb->transfer_dma valid on submit     //根据输入设备信息 注册设备    error = input_register_device(xpad->dev);    if (error)        goto fail5;    usb_set_intfdata(intf, xpad);    return 0;fail5: if (input_dev)        input_ff_destroy(input_dev);   //free force feedback structuresfail4: xpad_deinit_output(xpad);  //free out urb and out dmafail3: usb_free_urb(xpad->irq_in); //free in urbfail2: usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma);  //free in dmafail1: input_free_device(input_dev); //free input_dev    kfree(xpad); //free xpad    return error;}

//.........这里部分代码省略.........		for (i = 0; xpad_btn_triggers[i] >= 0; i++)			__set_bit(xpad_btn_triggers[i], input_dev->keybit);	} else {		for (i = 0; xpad_abs_triggers[i] >= 0; i++)			xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);	}	error = xpad_init_output(intf, xpad);	if (error)		goto fail3;	error = xpad_init_ff(xpad);	if (error)		goto fail4;	error = xpad_led_probe(xpad);	if (error)		goto fail5;	ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;	usb_fill_int_urb(xpad->irq_in, udev,			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,			 xpad, ep_irq_in->bInterval);	xpad->irq_in->transfer_dma = xpad->idata_dma;	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	error = input_register_device(xpad->dev);	if (error)		goto fail6;	usb_set_intfdata(intf, xpad);	if (xpad->xtype == XTYPE_XBOX360W) {		/*		 * Setup the message to set the LEDs on the		 * controller when it shows up		 */		xpad->bulk_out = usb_alloc_urb(0, GFP_KERNEL);		if (!xpad->bulk_out) {			error = -ENOMEM;			goto fail7;		}		xpad->bdata = kzalloc(XPAD_PKT_LEN, GFP_KERNEL);		if (!xpad->bdata) {			error = -ENOMEM;			goto fail8;		}		xpad->bdata[2] = 0x08;		switch (intf->cur_altsetting->desc.bInterfaceNumber) {		case 0:			xpad->bdata[3] = 0x42;			break;		case 2:			xpad->bdata[3] = 0x43;			break;		case 4:			xpad->bdata[3] = 0x44;			break;		case 6:			xpad->bdata[3] = 0x45;		}		ep_irq_in = &intf->cur_altsetting->endpoint[1].desc;		usb_fill_bulk_urb(xpad->bulk_out, udev,				usb_sndbulkpipe(udev, ep_irq_in->bEndpointAddress),				xpad->bdata, XPAD_PKT_LEN, xpad_bulk_out, xpad);		/*		 * Submit the int URB immediately rather than waiting for open		 * because we get status messages from the device whether		 * or not any controllers are attached.  In fact, it's		 * exactly the message that a controller has arrived that		 * we're waiting for.		 */		xpad->irq_in->dev = xpad->udev;		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);		if (error)			goto fail9;	}	return 0; fail9:	kfree(xpad->bdata); fail8:	usb_free_urb(xpad->bulk_out); fail7:	input_unregister_device(input_dev);	input_dev = NULL; fail6:	xpad_led_disconnect(xpad); fail5:	if (input_dev)		input_ff_destroy(input_dev); fail4:	xpad_deinit_output(xpad); fail3:	usb_free_urb(xpad->irq_in); fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); fail1:	input_free_device(input_dev);	kfree(xpad);	return error;}

//.........这里部分代码省略.........	int_in_endpointAddr = endpoint->bEndpointAddress;	/* allocate memory for our device state and initialize it */	pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL);	if (!pdata) {		retval = -ENOMEM;		goto error;	}	pdata->udev = udev;	INIT_DELAYED_WORK(&pdata->work, appledisplay_work);	mutex_init(&pdata->sysfslock);	/* Allocate buffer for control messages */	pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);	if (!pdata->msgdata) {		retval = -ENOMEM;		goto error;	}	/* Allocate interrupt URB */	pdata->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!pdata->urb) {		retval = -ENOMEM;		goto error;	}	/* Allocate buffer for interrupt data */	pdata->urbdata = usb_alloc_coherent(pdata->udev, ACD_URB_BUFFER_LEN,		GFP_KERNEL, &pdata->urb->transfer_dma);	if (!pdata->urbdata) {		retval = -ENOMEM;		dev_err(&iface->dev, "Allocating URB buffer failed/n");		goto error;	}	/* Configure interrupt URB */	usb_fill_int_urb(pdata->urb, udev,		usb_rcvintpipe(udev, int_in_endpointAddr),		pdata->urbdata, ACD_URB_BUFFER_LEN, appledisplay_complete,		pdata, 1);	pdata->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;	if (usb_submit_urb(pdata->urb, GFP_KERNEL)) {		retval = -EIO;		dev_err(&iface->dev, "Submitting URB failed/n");		goto error;	}	/* Register backlight device */	snprintf(bl_name, sizeof(bl_name), "appledisplay%d",		atomic_inc_return(&count_displays) - 1);	memset(&props, 0, sizeof(struct backlight_properties));	props.type = BACKLIGHT_RAW;	props.max_brightness = 0xff;	pdata->bd = backlight_device_register(bl_name, NULL, pdata,					      &appledisplay_bl_data, &props);	if (IS_ERR(pdata->bd)) {		dev_err(&iface->dev, "Backlight registration failed/n");		retval = PTR_ERR(pdata->bd);		goto error;	}	/* Try to get brightness */	brightness = appledisplay_bl_get_brightness(pdata->bd);	if (brightness < 0) {		retval = brightness;		dev_err(&iface->dev,			"Error while getting initial brightness: %d/n", retval);		goto error;	}	/* Set brightness in backlight device */	pdata->bd->props.brightness = brightness;	/* save our data pointer in the interface device */	usb_set_intfdata(iface, pdata);	printk(KERN_INFO "appledisplay: Apple Cinema Display connected/n");	return 0;error:	if (pdata) {		if (pdata->urb) {			usb_kill_urb(pdata->urb);			if (pdata->urbdata)				usb_free_coherent(pdata->udev, ACD_URB_BUFFER_LEN,					pdata->urbdata, pdata->urb->transfer_dma);			usb_free_urb(pdata->urb);		}		if (!IS_ERR(pdata->bd))			backlight_device_unregister(pdata->bd);		kfree(pdata->msgdata);	}	usb_set_intfdata(iface, NULL);	kfree(pdata);	return retval;}

static void ar5523_free_rx_cmd(struct ar5523 *ar){	usb_free_coherent(ar->dev, AR5523_MAX_RXCMDSZ,			  ar->rx_cmd_buf, ar->rx_cmd_urb->transfer_dma);	usb_free_urb(ar->rx_cmd_urb);}

//.........这里部分代码省略.........	case USB_DEVICE_ID_CODEMERCS_IOWPV2:	case USB_DEVICE_ID_CODEMERCS_IOW40:		/* IOW24 and IOW40 use a synchronous call */		buf = kmalloc(count, GFP_KERNEL);		if (!buf) {			retval = -ENOMEM;			goto exit;		}		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			kfree(buf);			goto exit;		}		retval = usb_set_report(dev->interface, 2, 0, buf, count);		kfree(buf);		goto exit;		break;	case USB_DEVICE_ID_CODEMERCS_IOW56:		/* The IOW56 uses asynchronous IO and more urbs */		if (atomic_read(&dev->write_busy) == MAX_WRITES_IN_FLIGHT) {			/* Wait until we are below the limit for submitted urbs */			if (file->f_flags & O_NONBLOCK) {				retval = -EAGAIN;				goto exit;			} else {				retval = wait_event_interruptible(dev->write_wait,								  (!dev->present || (atomic_read (&dev-> write_busy) < MAX_WRITES_IN_FLIGHT)));				if (retval) {					/* we were interrupted by a signal */					retval = -ERESTART;					goto exit;				}				if (!dev->present) {					/* The device was unplugged */					retval = -ENODEV;					goto exit;				}				if (!dev->opened) {					/* We were closed while waiting for an URB */					retval = -ENODEV;					goto exit;				}			}		}		atomic_inc(&dev->write_busy);		int_out_urb = usb_alloc_urb(0, GFP_KERNEL);		if (!int_out_urb) {			retval = -ENOMEM;			dbg("%s Unable to allocate urb ", __func__);			goto error_no_urb;		}		buf = usb_alloc_coherent(dev->udev, dev->report_size,					 GFP_KERNEL, &int_out_urb->transfer_dma);		if (!buf) {			retval = -ENOMEM;			dbg("%s Unable to allocate buffer ", __func__);			goto error_no_buffer;		}		usb_fill_int_urb(int_out_urb, dev->udev,				 usb_sndintpipe(dev->udev,						dev->int_out_endpoint->bEndpointAddress),				 buf, dev->report_size,				 iowarrior_write_callback, dev,				 dev->int_out_endpoint->bInterval);		int_out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			goto error;		}		retval = usb_submit_urb(int_out_urb, GFP_KERNEL);		if (retval) {			dbg("%s submit error %d for urb nr.%d", __func__,			    retval, atomic_read(&dev->write_busy));			goto error;		}		/* submit was ok */		retval = count;		usb_free_urb(int_out_urb);		goto exit;		break;	default:		/* what do we have here ? An unsupported Product-ID ? */		dev_err(&dev->interface->dev, "%s - not supported for product=0x%x/n",			__func__, dev->product_id);		retval = -EFAULT;		goto exit;		break;	}error:	usb_free_coherent(dev->udev, dev->report_size, buf,			  int_out_urb->transfer_dma);error_no_buffer:	usb_free_urb(int_out_urb);error_no_urb:	atomic_dec(&dev->write_busy);	wake_up_interruptible(&dev->write_wait);exit:	mutex_unlock(&dev->mutex);	return retval;}

static netdev_tx_t ems_usb_start_xmit(struct sk_buff *skb, struct net_device *netdev){	struct ems_usb *dev = netdev_priv(netdev);	struct ems_tx_urb_context *context = NULL;	struct net_device_stats *stats = &netdev->stats;	struct can_frame *cf = (struct can_frame *)skb->data;	struct ems_cpc_msg *msg;	struct urb *urb;	u8 *buf;	int i, err;	size_t size = CPC_HEADER_SIZE + CPC_MSG_HEADER_LEN			+ sizeof(struct cpc_can_msg);	if (can_dropped_invalid_skb(netdev, skb))		return NETDEV_TX_OK;	/* create a URB, and a buffer for it, and copy the data to the URB */	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb) {		netdev_err(netdev, "No memory left for URBs/n");		goto nomem;	}	buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma);	if (!buf) {		netdev_err(netdev, "No memory left for USB buffer/n");		usb_free_urb(urb);		goto nomem;	}	msg = (struct ems_cpc_msg *)&buf[CPC_HEADER_SIZE];	msg->msg.can_msg.id = cpu_to_le32(cf->can_id & CAN_ERR_MASK);	msg->msg.can_msg.length = cf->can_dlc;	if (cf->can_id & CAN_RTR_FLAG) {		msg->type = cf->can_id & CAN_EFF_FLAG ?			CPC_CMD_TYPE_EXT_RTR_FRAME : CPC_CMD_TYPE_RTR_FRAME;		msg->length = CPC_CAN_MSG_MIN_SIZE;	} else {		msg->type = cf->can_id & CAN_EFF_FLAG ?			CPC_CMD_TYPE_EXT_CAN_FRAME : CPC_CMD_TYPE_CAN_FRAME;		for (i = 0; i < cf->can_dlc; i++)			msg->msg.can_msg.msg[i] = cf->data[i];		msg->length = CPC_CAN_MSG_MIN_SIZE + cf->can_dlc;	}	for (i = 0; i < MAX_TX_URBS; i++) {		if (dev->tx_contexts[i].echo_index == MAX_TX_URBS) {			context = &dev->tx_contexts[i];			break;		}	}	/*	 * May never happen! When this happens we'd more URBs in flight as	 * allowed (MAX_TX_URBS).	 */	if (!context) {		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);		usb_free_urb(urb);		netdev_warn(netdev, "couldn't find free context/n");		return NETDEV_TX_BUSY;	}	context->dev = dev;	context->echo_index = i;	context->dlc = cf->can_dlc;	usb_fill_bulk_urb(urb, dev->udev, usb_sndbulkpipe(dev->udev, 2), buf,			  size, ems_usb_write_bulk_callback, context);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->tx_submitted);	can_put_echo_skb(skb, netdev, context->echo_index);	atomic_inc(&dev->active_tx_urbs);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		can_free_echo_skb(netdev, context->echo_index);		usb_unanchor_urb(urb);		usb_free_coherent(dev->udev, size, buf, urb->transfer_dma);		dev_kfree_skb(skb);		atomic_dec(&dev->active_tx_urbs);		if (err == -ENODEV) {			netif_device_detach(netdev);		} else {			netdev_warn(netdev, "failed tx_urb %d/n", err);			stats->tx_dropped++;		}//.........这里部分代码省略.........

//.........这里部分代码省略.........	desc = kzalloc(sizeof(struct wdm_device), GFP_KERNEL);	if (!desc)		goto out;	mutex_init(&desc->lock);	spin_lock_init(&desc->iuspin);	init_waitqueue_head(&desc->wait);	desc->wMaxCommand = maxcom;	/* this will be expanded and needed in hardware endianness */	desc->inum = cpu_to_le16((u16)intf->cur_altsetting->desc.bInterfaceNumber);	desc->intf = intf;	INIT_WORK(&desc->rxwork, wdm_rxwork);	rv = -EINVAL;	iface = intf->cur_altsetting;	if (iface->desc.bNumEndpoints != 1)		goto err;	ep = &iface->endpoint[0].desc;	if (!ep || !usb_endpoint_is_int_in(ep))		goto err;	desc->wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);	desc->bMaxPacketSize0 = udev->descriptor.bMaxPacketSize0;	desc->orq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);	if (!desc->orq)		goto err;	desc->irq = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);	if (!desc->irq)		goto err;	desc->validity = usb_alloc_urb(0, GFP_KERNEL);	if (!desc->validity)		goto err;	desc->response = usb_alloc_urb(0, GFP_KERNEL);	if (!desc->response)		goto err;	desc->command = usb_alloc_urb(0, GFP_KERNEL);	if (!desc->command)		goto err;	desc->ubuf = kmalloc(desc->wMaxCommand, GFP_KERNEL);	if (!desc->ubuf)		goto err;	desc->sbuf = usb_alloc_coherent(interface_to_usbdev(intf),					desc->wMaxPacketSize,					GFP_KERNEL,					&desc->validity->transfer_dma);	if (!desc->sbuf)		goto err;	desc->inbuf = usb_alloc_coherent(interface_to_usbdev(intf),					 desc->bMaxPacketSize0,					 GFP_KERNEL,					 &desc->response->transfer_dma);	if (!desc->inbuf)		goto err2;	usb_fill_int_urb(		desc->validity,		interface_to_usbdev(intf),		usb_rcvintpipe(interface_to_usbdev(intf), ep->bEndpointAddress),		desc->sbuf,		desc->wMaxPacketSize,		wdm_int_callback,		desc,		ep->bInterval	);	desc->validity->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_set_intfdata(intf, desc);	rv = usb_register_dev(intf, &wdm_class);	if (rv < 0)		goto err3;	else		dev_info(&intf->dev, "cdc-wdm%d: USB WDM device/n",			intf->minor - WDM_MINOR_BASE);out:	return rv;err3:	usb_set_intfdata(intf, NULL);	usb_free_coherent(interface_to_usbdev(desc->intf),			  desc->bMaxPacketSize0,			desc->inbuf,			desc->response->transfer_dma);err2:	usb_free_coherent(interface_to_usbdev(desc->intf),			  desc->wMaxPacketSize,			  desc->sbuf,			  desc->validity->transfer_dma);err:	free_urbs(desc);	kfree(desc->ubuf);	kfree(desc->orq);	kfree(desc->irq);	kfree(desc);	return rv;}

//.........这里部分代码省略.........	usb_make_path(dev, mouse->phys, 64/*sizeof(mouse->phys)*/);	strlcat(mouse->phys, "/input0", 64/*sizeof(mouse->phys)*/);		//@ open input_dev_unregistered(input_dev, _, _, _, _, _, _);		input_dev->name = mouse->name;	input_dev->phys = mouse->phys;	//@ close usb_device(dev, _);	usb_to_input_id(dev, &input_dev->id);	//@ open usb_device(dev, _);	//TODO: input_dev->dev.parent = &intf->dev;	//TODO:	/*input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |		BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);	input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |		BIT_MASK(BTN_EXTRA);	input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);*/		//@ close input_dev_unregistered(input_dev, _, _, _, _, _, _);	input_set_drvdata(input_dev, mouse);		//@ open input_dev_unregistered(input_dev, _, _, _, _, _, _);	input_dev->open = usb_mouse_open;	input_dev->close = usb_mouse_close;	input_dev->event = usb_mouse_event_dummy; // not original code, HACK		//@ close usb_device(dev, _);	//@ close complete_t_ghost_param(usb_mouse_irq, usb_mouse_irq);	usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,			 (maxp > 8 ? 8 : maxp),			 usb_mouse_irq, mouse, endpoint->bInterval);	mouse->irq->transfer_dma = mouse->data_dma;	mouse->irq->transfer_flags = mouse->irq->transfer_flags | URB_NO_TRANSFER_DMA_MAP;		/*@ urb_transfer_flags_add_no_transfer_dma_map(		mouse->irq, data_tmp, mouse->data_dma, 8, mouse->irq->transfer_flags); @*/	//@ assert mouse->irq |-> ?irq;	//@ close urb_struct(true, irq, _, data_tmp, mouse->data_dma, 8, true, usb_mouse_irq, mouse, 0);		//@ close input_open_t_ghost_param(usb_mouse_open, usb_mouse_open);	//@ close input_close_t_ghost_param(usb_mouse_close, usb_mouse_close);	//@ assume(is_input_event_t_no_pointer(usb_mouse_event_dummy) == true); // HACK HACK HACK, there are no events for this driver	//@ close input_event_t_ghost_param(usb_mouse_event_dummy, usb_mouse_event_dummy);		//@ close input_dev_unregistered(input_dev, _, _, _, _, _, _);		//@ input_ghost_register_device(input_dev, fracsize);	//@ close input_open_callback_link(usb_mouse_open)(usb_mouse_close, usb_mouse_event_dummy);	//@ close input_close_callback_link(usb_mouse_close)(usb_mouse_open, usb_mouse_event_dummy);	//@ close input_event_callback_link(usb_mouse_event_dummy)(usb_mouse_open, usb_mouse_close);	//@ assert input_dev_ghost_registered(_, _, _, _, _, _, _, _, ?input_register_result);	/*@	if (input_register_result == 0){		close userdef_input_drvdata(usb_mouse_open, usb_mouse_close, usb_mouse_event_dummy)(input_dev, false, mouse, fracsize);	}	@*/	//@ assume( true && (void*) 0 != ((void*) mouse->phys));	//@ assert chars(mouse->phys, 64, ?phys_text);	//@ close maybe_chars(1, mouse->phys, 64, phys_text);	error = input_register_device(mouse->dev);	if (error != 0) {		//@ open maybe_chars(1, _, _, _);		//@ open input_open_callback_link(usb_mouse_open)(usb_mouse_close, usb_mouse_event_dummy);		//@ open input_close_callback_link(usb_mouse_close)(usb_mouse_open, usb_mouse_event_dummy);		//@ open input_event_callback_link(usb_mouse_event_dummy)(usb_mouse_open, usb_mouse_close);		//@ open input_open_t_ghost_param(usb_mouse_open, usb_mouse_open);		//@ open input_close_t_ghost_param(usb_mouse_close, usb_mouse_close);		//@ open input_event_t_ghost_param(usb_mouse_event_dummy, usb_mouse_event_dummy);		goto fail3;	}	//@ close usb_interface_descriptor(&interface->desc, 1, _);	//@ close usb_host_endpoint(interface->endpoint);	//@ close [f2]usb_host_interface(interface);	//@ close usb_interface(usb_mouse_probe, usb_mouse_disconnect, intf, dev, originalData, false, fracsize);	//@ close userdef_usb_interface_data(usb_mouse_probe, usb_mouse_disconnect)(intf, dev, mouse, fracsize);	usb_set_intfdata(intf, mouse);	return 0;fail3:	   	//@ close urb_struct_maybe(true, irq, _, _, _, _, _, _, _, _);	usb_free_urb(mouse->irq);fail2:		usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);	//@ open_struct(mouse);	//@ chars_to_uchars(mouse);fail1:		input_free_device(input_dev);	kfree(mouse);	//@ close [f3]usb_interface_descriptor(&interface->desc, bNumEndpoints, bInterfaceNumber);	//@ close usb_host_endpoint(interface->endpoint);	//@ close [f2]usb_host_interface(interface);	//@ close usb_interface(usb_mouse_probe, disconnect_cb, intf, _, originalData, false, fracsize);	return error;}

//.........这里部分代码省略.........	case USB_DEVICE_ID_CODEMERCS_IOWPV2:	case USB_DEVICE_ID_CODEMERCS_IOW40:		/*                                        */		buf = kmalloc(count, GFP_KERNEL);		if (!buf) {			retval = -ENOMEM;			goto exit;		}		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			kfree(buf);			goto exit;		}		retval = usb_set_report(dev->interface, 2, 0, buf, count);		kfree(buf);		goto exit;		break;	case USB_DEVICE_ID_CODEMERCS_IOW56:		/*                                              */		if (atomic_read(&dev->write_busy) == MAX_WRITES_IN_FLIGHT) {			/*                                                      */			if (file->f_flags & O_NONBLOCK) {				retval = -EAGAIN;				goto exit;			} else {				retval = wait_event_interruptible(dev->write_wait,								  (!dev->present || (atomic_read (&dev-> write_busy) < MAX_WRITES_IN_FLIGHT)));				if (retval) {					/*                                 */					retval = -ERESTART;					goto exit;				}				if (!dev->present) {					/*                          */					retval = -ENODEV;					goto exit;				}				if (!dev->opened) {					/*                                         */					retval = -ENODEV;					goto exit;				}			}		}		atomic_inc(&dev->write_busy);		int_out_urb = usb_alloc_urb(0, GFP_KERNEL);		if (!int_out_urb) {			retval = -ENOMEM;			dbg("%s Unable to allocate urb ", __func__);			goto error_no_urb;		}		buf = usb_alloc_coherent(dev->udev, dev->report_size,					 GFP_KERNEL, &int_out_urb->transfer_dma);		if (!buf) {			retval = -ENOMEM;			dbg("%s Unable to allocate buffer ", __func__);			goto error_no_buffer;		}		usb_fill_int_urb(int_out_urb, dev->udev,				 usb_sndintpipe(dev->udev,						dev->int_out_endpoint->bEndpointAddress),				 buf, dev->report_size,				 iowarrior_write_callback, dev,				 dev->int_out_endpoint->bInterval);		int_out_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		if (copy_from_user(buf, user_buffer, count)) {			retval = -EFAULT;			goto error;		}		retval = usb_submit_urb(int_out_urb, GFP_KERNEL);		if (retval) {			dbg("%s submit error %d for urb nr.%d", __func__,			    retval, atomic_read(&dev->write_busy));			goto error;		}		/*               */		retval = count;		usb_free_urb(int_out_urb);		goto exit;		break;	default:		/*                                                    */		dev_err(&dev->interface->dev, "%s - not supported for product=0x%x/n",			__func__, dev->product_id);		retval = -EFAULT;		goto exit;		break;	}error:	usb_free_coherent(dev->udev, dev->report_size, buf,			  int_out_urb->transfer_dma);error_no_buffer:	usb_free_urb(int_out_urb);error_no_urb:	atomic_dec(&dev->write_busy);	wake_up_interruptible(&dev->write_wait);exit:	mutex_unlock(&dev->mutex);	return retval;}

static int igorplugusb_remote_probe(struct usb_interface *intf,				    const struct usb_device_id *id){	struct usb_device *dev = NULL;	struct usb_host_interface *idesc = NULL;	struct usb_endpoint_descriptor *ep;	struct igorplug *ir = NULL;	struct lirc_driver *driver = NULL;	int devnum, pipe, maxp;	int minor = 0;	char buf[63], name[128] = "";	int mem_failure = 0;	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);	mem_failure = 0;	ir = kzalloc(sizeof(struct igorplug), GFP_KERNEL);	if (!ir) {		mem_failure = 1;		goto mem_failure_switch;	}	driver = kzalloc(sizeof(struct lirc_driver), GFP_KERNEL);	if (!driver) {		mem_failure = 2;		goto mem_failure_switch;	}	ir->buf_in = usb_alloc_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,					GFP_ATOMIC, &ir->dma_in);	if (!ir->buf_in) {		mem_failure = 3;		goto mem_failure_switch;	}	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;	minor = lirc_register_driver(driver);	if (minor < 0)		mem_failure = 9;mem_failure_switch:	switch (mem_failure) {	case 9:		usb_free_coherent(dev, DEVICE_BUFLEN + DEVICE_HEADERLEN,			ir->buf_in, ir->dma_in);	case 3:		kfree(driver);	case 2:		kfree(ir);	case 1:		printk(DRIVER_NAME "[%d]: out of memory (code=%d)/n",			devnum, mem_failure);		return -ENOMEM;	}	driver->minor = minor;	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,//.........这里部分代码省略.........

static int usb_mouse_probe(struct usb_interface *intf, const struct usb_device_id *id){	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;	int error = -ENOMEM;	interface = intf->cur_altsetting;	if (interface->desc.bNumEndpoints != 1)		return -ENODEV;	endpoint = &interface->endpoint[0].desc;	if (!usb_endpoint_is_int_in(endpoint))		return -ENODEV;	pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);	maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));	mouse = kzalloc(sizeof(struct usb_mouse), GFP_KERNEL);	input_dev = input_allocate_device();	if (!mouse || !input_dev)		goto fail1;	mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma);	if (!mouse->data)		goto fail1;	mouse->irq = usb_alloc_urb(0, GFP_KERNEL);	if (!mouse->irq)		goto fail2;	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(dev, mouse->phys, sizeof(mouse->phys));	strlcat(mouse->phys, "/input0", sizeof(mouse->phys));	input_dev->name = mouse->name;	input_dev->phys = mouse->phys;	usb_to_input_id(dev, &input_dev->id);	input_dev->dev.parent = &intf->dev;	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |		BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);	input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y);	input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |		BIT_MASK(BTN_EXTRA);	input_dev->relbit[0] |= BIT_MASK(REL_WHEEL);	input_set_drvdata(input_dev, mouse);	input_dev->open = usb_mouse_open;	input_dev->close = usb_mouse_close;	usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,			 (maxp > 8 ? 8 : maxp),			 usb_mouse_irq, mouse, endpoint->bInterval);	mouse->irq->transfer_dma = mouse->data_dma;	mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	error = input_register_device(mouse->dev);	if (error)		goto fail3;	usb_set_intfdata(intf, mouse);	return 0;fail3:		usb_free_urb(mouse->irq);fail2:		usb_free_coherent(dev, 8, mouse->data, mouse->data_dma);fail1:		input_free_device(input_dev);	kfree(mouse);	return error;}

static void xpad_deinit_output(struct usb_xpad *xpad){	usb_free_urb(xpad->irq_out);	usb_free_coherent(xpad->udev, XPAD_PKT_LEN,				xpad->odata, xpad->odata_dma);}

//.........这里部分代码省略.........	input_dev->name = xpad_device[i].name;	input_dev->phys = xpad->phys;	usb_to_input_id(udev, &input_dev->id);	input_dev->dev.parent = &intf->dev;	input_set_drvdata(input_dev, xpad);	input_dev->open = xpad_open;	input_dev->close = xpad_close;	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);	/* set up standard buttons and axes */	for (i = 0; xpad_common_btn[i] >= 0; i++)		__set_bit(xpad_common_btn[i], input_dev->keybit);	for (i = 0; xpad_abs[i] >= 0; i++)		xpad_set_up_abs(input_dev, xpad_abs[i]);	/* Now set up model-specific ones */	if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX360W) {		for (i = 0; xpad360_btn[i] >= 0; i++)			__set_bit(xpad360_btn[i], input_dev->keybit);	} else {		for (i = 0; xpad_btn[i] >= 0; i++)			__set_bit(xpad_btn[i], input_dev->keybit);	}	if (xpad->mapping & MAP_DPAD_TO_BUTTONS) {		for (i = 0; xpad_btn_pad[i] >= 0; i++)			__set_bit(xpad_btn_pad[i], input_dev->keybit);	} else {		for (i = 0; xpad_abs_pad[i] >= 0; i++)		    xpad_set_up_abs(input_dev, xpad_abs_pad[i]);	}	if (xpad->mapping & MAP_TRIGGERS_TO_BUTTONS) {		for (i = 0; xpad_btn_triggers[i] >= 0; i++)			__set_bit(xpad_btn_triggers[i], input_dev->keybit);	} else {		for (i = 0; xpad_abs_triggers[i] >= 0; i++)			xpad_set_up_abs(input_dev, xpad_abs_triggers[i]);	}	error = xpad_init_output(intf, xpad);	if (error)		goto fail2;	error = xpad_init_ff(xpad);	if (error)		goto fail3;	error = xpad_led_probe(xpad);	if (error)		goto fail3;	ep_irq_in = &intf->cur_altsetting->endpoint[0].desc;	usb_fill_int_urb(xpad->irq_in, udev,			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,			 xpad, ep_irq_in->bInterval);	xpad->irq_in->transfer_dma = xpad->idata_dma;	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	INIT_WORK(&xpad->submit_urb, xpad_do_submit_urb);	error = input_register_device(xpad->dev);	if (error)		goto fail4;	usb_set_intfdata(intf, xpad);	xpad->interface_number = intf->cur_altsetting->desc.bInterfaceNumber;	/*	 * Submit the int URB immediatly rather than waiting for open	 * because we get status messages from the device whether	 * or not any controllers are attached.  In fact, it's	 * exactly the message that a controller has arrived that	 * we're waiting for.	 */	if (xpad->xtype == XTYPE_XBOX360W) {		xpad->irq_in->dev = xpad->udev;		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);		if (error)			goto fail4;	}	return 0; fail4:	cancel_work_sync(&xpad->submit_urb);	usb_free_urb(xpad->irq_in); fail3:	xpad_deinit_output(xpad); fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); fail1:	input_free_device(input_dev);	kfree(xpad);	return error;}

static int kbtab_probe(struct usb_interface *intf, const struct usb_device_id *id){	struct usb_device *dev = interface_to_usbdev(intf);	struct usb_endpoint_descriptor *endpoint;	struct kbtab *kbtab;	struct input_dev *input_dev;	int error = -ENOMEM;	kbtab = kzalloc(sizeof(struct kbtab), GFP_KERNEL);	input_dev = input_allocate_device();	if (!kbtab || !input_dev)		goto fail1;	kbtab->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &kbtab->data_dma);	if (!kbtab->data)		goto fail1;	kbtab->irq = usb_alloc_urb(0, GFP_KERNEL);	if (!kbtab->irq)		goto fail2;	kbtab->intf = intf;	kbtab->dev = input_dev;	usb_make_path(dev, kbtab->phys, sizeof(kbtab->phys));	strlcat(kbtab->phys, "/input0", sizeof(kbtab->phys));	input_dev->name = "KB Gear Tablet";	input_dev->phys = kbtab->phys;	usb_to_input_id(dev, &input_dev->id);	input_dev->dev.parent = &intf->dev;	input_set_drvdata(input_dev, kbtab);	input_dev->open = kbtab_open;	input_dev->close = kbtab_close;	input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);	input_dev->keybit[BIT_WORD(BTN_LEFT)] |=		BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_RIGHT);	input_dev->keybit[BIT_WORD(BTN_DIGI)] |=		BIT_MASK(BTN_TOOL_PEN) | BIT_MASK(BTN_TOUCH);	input_set_abs_params(input_dev, ABS_X, 0, 0x2000, 4, 0);	input_set_abs_params(input_dev, ABS_Y, 0, 0x1750, 4, 0);	input_set_abs_params(input_dev, ABS_PRESSURE, 0, 0xff, 0, 0);	endpoint = &intf->cur_altsetting->endpoint[0].desc;	usb_fill_int_urb(kbtab->irq, dev,			 usb_rcvintpipe(dev, endpoint->bEndpointAddress),			 kbtab->data, 8,			 kbtab_irq, kbtab, endpoint->bInterval);	kbtab->irq->transfer_dma = kbtab->data_dma;	kbtab->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	error = input_register_device(kbtab->dev);	if (error)		goto fail3;	usb_set_intfdata(intf, kbtab);	return 0; fail3:	usb_free_urb(kbtab->irq); fail2:	usb_free_coherent(dev, 8, kbtab->data, kbtab->data_dma); fail1:	input_free_device(input_dev);	kfree(kbtab);	return error;}

/* * Start interface */static int ems_usb_start(struct ems_usb *dev){	struct net_device *netdev = dev->netdev;	int err, i;	dev->intr_in_buffer[0] = 0;	dev->free_slots = 50; /* initial size */	for (i = 0; i < MAX_RX_URBS; i++) {		struct urb *urb = NULL;		u8 *buf = NULL;		/* create a URB, and a buffer for it */		urb = usb_alloc_urb(0, GFP_KERNEL);		if (!urb) {			netdev_err(netdev, "No memory left for URBs/n");			err = -ENOMEM;			break;		}		buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL,					 &urb->transfer_dma);		if (!buf) {			netdev_err(netdev, "No memory left for USB buffer/n");			usb_free_urb(urb);			err = -ENOMEM;			break;		}		usb_fill_bulk_urb(urb, dev->udev, usb_rcvbulkpipe(dev->udev, 2),				  buf, RX_BUFFER_SIZE,				  ems_usb_read_bulk_callback, dev);		urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;		usb_anchor_urb(urb, &dev->rx_submitted);		err = usb_submit_urb(urb, GFP_KERNEL);		if (err) {			usb_unanchor_urb(urb);			usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf,					  urb->transfer_dma);			usb_free_urb(urb);			break;		}		/* Drop reference, USB core will take care of freeing it */		usb_free_urb(urb);	}	/* Did we submit any URBs */	if (i == 0) {		netdev_warn(netdev, "couldn't setup read URBs/n");		return err;	}	/* Warn if we've couldn't transmit all the URBs */	if (i < MAX_RX_URBS)		netdev_warn(netdev, "rx performance may be slow/n");	/* Setup and start interrupt URB */	usb_fill_int_urb(dev->intr_urb, dev->udev,			 usb_rcvintpipe(dev->udev, 1),			 dev->intr_in_buffer,			 INTR_IN_BUFFER_SIZE,			 ems_usb_read_interrupt_callback, dev, 1);	err = usb_submit_urb(dev->intr_urb, GFP_KERNEL);	if (err) {		netdev_warn(netdev, "intr URB submit failed: %d/n", err);		return err;	}	/* CPC-USB will transfer received message to host */	err = ems_usb_control_cmd(dev, CONTR_CAN_MESSAGE | CONTR_CONT_ON);	if (err)		goto failed;	/* CPC-USB will transfer CAN state changes to host */	err = ems_usb_control_cmd(dev, CONTR_CAN_STATE | CONTR_CONT_ON);	if (err)		goto failed;	/* CPC-USB will transfer bus errors to host */	err = ems_usb_control_cmd(dev, CONTR_BUS_ERROR | CONTR_CONT_ON);	if (err)		goto failed;	err = ems_usb_write_mode(dev, SJA1000_MOD_NORMAL);	if (err)		goto failed;	dev->can.state = CAN_STATE_ERROR_ACTIVE;	return 0;failed:	netdev_warn(netdev, "couldn't submit control: %d/n", err);//.........这里部分代码省略.........

//.........这里部分代码省略.........	xpad->mapping = xpad_device[i].mapping;	xpad->xtype = xpad_device[i].xtype;	xpad->name = xpad_device[i].name;	INIT_WORK(&xpad->work, presence_work_function);	if (xpad->xtype == XTYPE_UNKNOWN) {		if (intf->cur_altsetting->desc.bInterfaceClass == USB_CLASS_VENDOR_SPEC) {			if (intf->cur_altsetting->desc.bInterfaceProtocol == 129)				xpad->xtype = XTYPE_XBOX360W;			else				xpad->xtype = XTYPE_XBOX360;		} else			xpad->xtype = XTYPE_XBOX;		if (dpad_to_buttons)			xpad->mapping |= MAP_DPAD_TO_BUTTONS;		if (triggers_to_buttons)			xpad->mapping |= MAP_TRIGGERS_TO_BUTTONS;		if (sticks_to_null)			xpad->mapping |= MAP_STICKS_TO_NULL;	}	error = xpad_init_output(intf, xpad);	if (error)		goto fail3;	/* Xbox One controller has in/out endpoints swapped. */	ep_irq_in_idx = xpad->xtype == XTYPE_XBOXONE ? 1 : 0;	ep_irq_in = &intf->cur_altsetting->endpoint[ep_irq_in_idx].desc;	usb_fill_int_urb(xpad->irq_in, udev,			 usb_rcvintpipe(udev, ep_irq_in->bEndpointAddress),			 xpad->idata, XPAD_PKT_LEN, xpad_irq_in,			 xpad, ep_irq_in->bInterval);	xpad->irq_in->transfer_dma = xpad->idata_dma;	xpad->irq_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_set_intfdata(intf, xpad);	if (xpad->xtype == XTYPE_XBOX360W) {		/*		 * Submit the int URB immediately rather than waiting for open		 * because we get status messages from the device whether		 * or not any controllers are attached.  In fact, it's		 * exactly the message that a controller has arrived that		 * we're waiting for.		 */		xpad->irq_in->dev = xpad->udev;		error = usb_submit_urb(xpad->irq_in, GFP_KERNEL);		if (error) {			usb_kill_urb(xpad->irq_in);			goto fail4;		}		/*		 * send presence packet		 * This will force the controller to resend connection packets.		 * This is useful in the case we activate the module after the		 * adapter has been plugged in, as it won't automatically		 * send us info about the controllers.		 */		mutex_lock(&xpad->odata_mutex);		xpad->odata[0] = 0x08;		xpad->odata[1] = 0x00;		xpad->odata[2] = 0x0F;		xpad->odata[3] = 0xC0;		xpad->odata[4] = 0x00;		xpad->odata[5] = 0x00;		xpad->odata[6] = 0x00;		xpad->odata[7] = 0x00;		xpad->odata[8] = 0x00;		xpad->odata[9] = 0x00;		xpad->odata[10] = 0x00;		xpad->odata[11] = 0x00;		xpad->irq_out->transfer_buffer_length = 12;		if (!xpad->irq_out_active) {			usb_submit_urb(xpad->irq_out, GFP_KERNEL);			xpad->irq_out_active = 1;		} else			dev_dbg(&xpad->dev->dev,				"%s - dropped, irq_out is active/n", __func__);		mutex_unlock(&xpad->odata_mutex);	} else {		xpad->pad_present = 1;		error = xpad_init_input(xpad);		if (error)			goto fail4;	}	return 0; fail4:	xpad_deinit_output(xpad); fail3:	usb_free_urb(xpad->irq_in); fail2:	usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); fail1:	kfree(xpad);	return error;}

static ssize_t skel_write(struct file *file, const char *user_buffer,			  size_t count, loff_t *ppos){	struct usb_skel *dev;	int retval = 0;	struct urb *urb = NULL;	char *buf = NULL;	size_t writesize = min(count, (size_t)MAX_TRANSFER);	dev = file->private_data;		if (count == 0)		goto exit;	if (!(file->f_flags & O_NONBLOCK)) {		if (down_interruptible(&dev->limit_sem)) {			retval = -ERESTARTSYS;			goto exit;		}	} else {		if (down_trylock(&dev->limit_sem)) {			retval = -EAGAIN;			goto exit;		}	}	spin_lock_irq(&dev->err_lock);	retval = dev->errors;	if (retval < 0) {				dev->errors = 0;				retval = (retval == -EPIPE) ? retval : -EIO;	}	spin_unlock_irq(&dev->err_lock);	if (retval < 0)		goto error;		urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		retval = -ENOMEM;		goto error;	}	buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,				 &urb->transfer_dma);	if (!buf) {		retval = -ENOMEM;		goto error;	}	if (copy_from_user(buf, user_buffer, writesize)) {		retval = -EFAULT;		goto error;	}		mutex_lock(&dev->io_mutex);	if (!dev->interface) {				mutex_unlock(&dev->io_mutex);		retval = -ENODEV;		goto error;	}		usb_fill_bulk_urb(urb, dev->udev,			  usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),			  buf, writesize, skel_write_bulk_callback, dev);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->submitted);		retval = usb_submit_urb(urb, GFP_KERNEL);	mutex_unlock(&dev->io_mutex);	if (retval) {		err("%s - failed submitting write urb, error %d", __func__,		    retval);		goto error_unanchor;	}	usb_free_urb(urb);	return writesize;error_unanchor:	usb_unanchor_urb(urb);error:	if (urb) {		usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);		usb_free_urb(urb);	}	up(&dev->limit_sem);exit:	return retval;}

int zd_usb_enable_int(struct zd_usb *usb){	int r;	struct usb_device *udev = zd_usb_to_usbdev(usb);	struct zd_usb_interrupt *intr = &usb->intr;	struct urb *urb;	dev_dbg_f(zd_usb_dev(usb), "/n");	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		r = -ENOMEM;		goto out;	}	ZD_ASSERT(!irqs_disabled());	spin_lock_irq(&intr->lock);	if (intr->urb) {		spin_unlock_irq(&intr->lock);		r = 0;		goto error_free_urb;	}	intr->urb = urb;	spin_unlock_irq(&intr->lock);	r = -ENOMEM;	intr->buffer = usb_alloc_coherent(udev, USB_MAX_EP_INT_BUFFER,					  GFP_KERNEL, &intr->buffer_dma);	if (!intr->buffer) {		dev_dbg_f(zd_usb_dev(usb),			"couldn't allocate transfer_buffer/n");		goto error_set_urb_null;	}	usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),			 intr->buffer, USB_MAX_EP_INT_BUFFER,			 int_urb_complete, usb,			 intr->interval);	urb->transfer_dma = intr->buffer_dma;	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	dev_dbg_f(zd_usb_dev(usb), "submit urb %p/n", intr->urb);	r = usb_submit_urb(urb, GFP_KERNEL);	if (r) {		dev_dbg_f(zd_usb_dev(usb),			 "Couldn't submit urb. Error number %d/n", r);		goto error;	}	return 0;error:	usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,			  intr->buffer, intr->buffer_dma);error_set_urb_null:	spin_lock_irq(&intr->lock);	intr->urb = NULL;	spin_unlock_irq(&intr->lock);error_free_urb:	usb_free_urb(urb);out:	return r;}

//.........这里部分代码省略.........		ret = -ENOMEM;		goto out;	}	ir->buf_in = usb_alloc_coherent(udev, MAX_IN_PACKET, GFP_KERNEL,								&ir->dma_in);	ir->packet = usb_alloc_coherent(udev, MAX_OUT_PACKET, GFP_KERNEL,								&ir->dma_out);	ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);	ir->urb_out = usb_alloc_urb(0, GFP_KERNEL);	if (!ir->buf_in || !ir->packet || !ir->urb_in || !ir->urb_out) {		ret = -ENOMEM;		goto out;	}	idesc = intf->altsetting;	if (idesc->desc.bNumEndpoints < 2) {		ret = -ENODEV;		goto out;	}	ir->rc = rc;	ir->dev = &intf->dev;	ir->udev = udev;	mutex_init(&ir->lock);	init_completion(&ir->completion);	pipeout = usb_sndintpipe(udev,				idesc->endpoint[1].desc.bEndpointAddress);	usb_fill_int_urb(ir->urb_out, udev, pipeout, ir->packet, MAX_OUT_PACKET,						iguanair_irq_out, ir, 1);	ir->urb_out->transfer_dma = ir->dma_out;	ir->urb_out->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	pipein = usb_rcvintpipe(udev, idesc->endpoint[0].desc.bEndpointAddress);	usb_fill_int_urb(ir->urb_in, udev, pipein, ir->buf_in, MAX_IN_PACKET,							 iguanair_rx, ir, 1);	ir->urb_in->transfer_dma = ir->dma_in;	ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	ret = usb_submit_urb(ir->urb_in, GFP_KERNEL);	if (ret) {		dev_warn(&intf->dev, "failed to submit urb: %d/n", ret);		goto out;	}	ret = iguanair_get_features(ir);	if (ret)		goto out2;	snprintf(ir->name, sizeof(ir->name),		"IguanaWorks USB IR Transceiver version 0x%04x", ir->version);	usb_make_path(ir->udev, ir->phys, sizeof(ir->phys));	rc->input_name = ir->name;	rc->input_phys = ir->phys;	usb_to_input_id(ir->udev, &rc->input_id);	rc->dev.parent = &intf->dev;	rc->driver_type = RC_DRIVER_IR_RAW;	rc->allowed_protos = RC_BIT_ALL;	rc->priv = ir;	rc->open = iguanair_open;	rc->close = iguanair_close;	rc->s_tx_mask = iguanair_set_tx_mask;	rc->s_tx_carrier = iguanair_set_tx_carrier;	rc->tx_ir = iguanair_tx;	rc->driver_name = DRIVER_NAME;	rc->map_name = RC_MAP_RC6_MCE;	rc->timeout = MS_TO_NS(100);	rc->rx_resolution = RX_RESOLUTION;	iguanair_set_tx_carrier(rc, 38000);	ret = rc_register_device(rc);	if (ret < 0) {		dev_err(&intf->dev, "failed to register rc device %d", ret);		goto out2;	}	usb_set_intfdata(intf, ir);	return 0;out2:	usb_kill_urb(ir->urb_in);	usb_kill_urb(ir->urb_out);out:	if (ir) {		usb_free_urb(ir->urb_in);		usb_free_urb(ir->urb_out);		usb_free_coherent(udev, MAX_IN_PACKET, ir->buf_in, ir->dma_in);		usb_free_coherent(udev, MAX_OUT_PACKET, ir->packet,								ir->dma_out);	}	rc_free_device(rc);	kfree(ir);	return ret;}

//.........这里部分代码省略.........	pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL);	if (!pdata) {		retval = -ENOMEM;		dev_err(&iface->dev, "Out of memory/n");		goto error;	}	pdata->udev = udev;	spin_lock_init(&pdata->lock);	INIT_DELAYED_WORK(&pdata->work, appledisplay_work);		pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);	if (!pdata->msgdata) {		retval = -ENOMEM;		dev_err(&iface->dev,			"Allocating buffer for control messages failed/n");		goto error;	}		pdata->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!pdata->urb) {		retval = -ENOMEM;		dev_err(&iface->dev, "Allocating URB failed/n");		goto error;	}		pdata->urbdata = usb_alloc_coherent(pdata->udev, ACD_URB_BUFFER_LEN,		GFP_KERNEL, &pdata->urb->transfer_dma);	if (!pdata->urbdata) {		retval = -ENOMEM;		dev_err(&iface->dev, "Allocating URB buffer failed/n");		goto error;	}		usb_fill_int_urb(pdata->urb, udev,		usb_rcvintpipe(udev, int_in_endpointAddr),		pdata->urbdata, ACD_URB_BUFFER_LEN, appledisplay_complete,		pdata, 1);	if (usb_submit_urb(pdata->urb, GFP_KERNEL)) {		retval = -EIO;		dev_err(&iface->dev, "Submitting URB failed/n");		goto error;	}		snprintf(bl_name, sizeof(bl_name), "appledisplay%d",		atomic_inc_return(&count_displays) - 1);	memset(&props, 0, sizeof(struct backlight_properties));	props.type = BACKLIGHT_RAW;	props.max_brightness = 0xff;	pdata->bd = backlight_device_register(bl_name, NULL, pdata,					      &appledisplay_bl_data, &props);	if (IS_ERR(pdata->bd)) {		dev_err(&iface->dev, "Backlight registration failed/n");		retval = PTR_ERR(pdata->bd);		goto error;	}		brightness = appledisplay_bl_get_brightness(pdata->bd);	if (brightness < 0) {		retval = brightness;		dev_err(&iface->dev,			"Error while getting initial brightness: %d/n", retval);		goto error;	}		pdata->bd->props.brightness = brightness;		usb_set_intfdata(iface, pdata);	printk(KERN_INFO "appledisplay: Apple Cinema Display connected/n");	return 0;error:	if (pdata) {		if (pdata->urb) {			usb_kill_urb(pdata->urb);			if (pdata->urbdata)				usb_free_coherent(pdata->udev, ACD_URB_BUFFER_LEN,					pdata->urbdata, pdata->urb->transfer_dma);			usb_free_urb(pdata->urb);		}		if (pdata->bd && !IS_ERR(pdata->bd))			backlight_device_unregister(pdata->bd);		kfree(pdata->msgdata);	}	usb_set_intfdata(iface, NULL);	kfree(pdata);	return retval;}

//.........这里部分代码省略.........	input_dev1 = input_allocate_device();	input_dev1->name = "pixcir_usb_ts";	usb_to_input_id(dev, &input_dev1->id);	psmt->input_dev = input_dev1;	if(!psmt|| !input_dev1) {    printk("Memory is not enough/n");    goto fail1;	}	input_dev1->dev.parent = &intf->dev;	input_set_drvdata(input_dev1, psmt);	set_bit(EV_SYN, input_dev1->evbit);	set_bit(EV_KEY, input_dev1->evbit);	set_bit(EV_ABS, input_dev1->evbit);	set_bit(BTN_TOUCH, input_dev1->keybit);	input_set_abs_params(input_dev1, ABS_X, psmt->type->min_xc, psmt->type->max_xc, 0, 0);	input_set_abs_params(input_dev1, ABS_Y, psmt->type->min_yc, psmt->type->max_yc, 0, 0);	input_set_abs_params(input_dev1, ABS_MT_POSITION_X, psmt->type->min_xc, psmt->type->max_xc, 0, 0);	input_set_abs_params(input_dev1, ABS_MT_POSITION_Y, psmt->type->min_yc, psmt->type->max_yc, 0, 0);  input_set_abs_params(input_dev1, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);  input_set_abs_params(input_dev1, ABS_MT_WIDTH_MAJOR, 0, 25, 0, 0);  psmt->data = usb_alloc_coherent(dev, insize, GFP_KERNEL, &psmt->data_dma);  if(!psmt->data) {    printk("psmt->data allocating fail");    goto fail;  }  for (n = 0; n < interface->desc.bNumEndpoints; n++) {    struct usb_endpoint_descriptor *endpoint;    int pipe;    int interval;    endpoint = &interface->endpoint[n].desc;		/*find a int endpoint*/    if (!usb_endpoint_xfer_int(endpoint))                   continue;    interval = endpoint->bInterval;    if (usb_endpoint_dir_in(endpoint)) {      if (psmt->urb)        continue;      if (!(psmt->urb = usb_alloc_urb(0, GFP_KERNEL)))        goto fail;      pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);      usb_fill_int_urb(psmt->urb, dev, pipe, psmt->data, insize, pixcir_mt_irq, psmt, interval);      psmt->urb->transfer_dma = psmt->data_dma;      psmt->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;    }  }  if (usb_submit_urb(psmt->urb, GFP_ATOMIC)) {    printk("usb submit urb error/n");    return -EIO;  }  err = input_register_device(psmt->input_dev);  if(err) {    printk("pixcir_probe: Could not register input device(touchscreen)!/n");      return -EIO;  }  path = kobject_get_path(&psmt->input_dev->dev.kobj, GFP_KERNEL);  len=strlen(path);  if(len>10){		if(path[len-2]=='t'){			memset(input_buf,'/0',9);			strncpy(input_buf,&path[len-6],6);		}else if(path[len-3]=='t'){			memset(input_buf,'/0',9);			strncpy(input_buf,&path[len-7],7);		}else{			 goto fail;		}  }else{     	    goto fail;  }  usb_make_path(dev, psmt->phys0, sizeof(psmt->phys0));  strlcat(psmt->phys0,input_buf, sizeof(psmt->phys0));  return 0;fail:  usb_free_urb(psmt->urb);  psmt->urb = NULL;  usb_free_coherent(dev, insize, psmt->data, psmt->data_dma);fail1:  input_free_device(input_dev1);  kfree(psmt);  return 1;}

static ssize_t proto_write_periodic(unsigned long data){    //Size of buffer for dummy data    int count = 5;    struct usb_skel *dev;    int retval = 0;    struct urb *urb = NULL;    char *buf = NULL;    dev = (struct usb_skel *) data;    printk("Inside Timer Routine count-> %d/n",step++);    printk("Inside Timer idProduct %02X, idVendor %02X/n",dev->udev->descriptor.idProduct, dev->udev->descriptor.idVendor);    struct sysinfo kk;    si_meminfo(&kk);    //sys_sysinfo(&kk);        kk.uptime=jiffies/HZ;    int days=kk.uptime/86400;    int hours=kk.uptime/3600 - days*24;    int mins=(kk.uptime/60) - (days*1440) - (hours*60);	printk(KERN_INFO "Days since boot: %d/n", (days));    printk(KERN_INFO "Hours since boot: %d/n", (hours));    printk(KERN_INFO "Mins since boot: %d/n", (mins));    printk(KERN_INFO "Seconds since boot: %d/n", (kk.uptime));    printk(KERN_INFO "CPU load: %d/n", (kk.loads[0]));    printk(KERN_INFO "CPU load: %d/n", (avenrun[0] << (SI_LOAD_SHIFT - FSHIFT)));    printk(KERN_INFO "CPU load: %d/n", (avenrun[1] << (SI_LOAD_SHIFT - FSHIFT)));    printk(KERN_INFO "CPU load: %d/n", (avenrun[2] << (SI_LOAD_SHIFT - FSHIFT)));    int a, b, c;    a = avenrun[0] + (FIXED_1/200);    b = avenrun[1] + (FIXED_1/200);    c = avenrun[2] + (FIXED_1/200);    printk(KERN_INFO "%d.%02d %d.%02d %d.%02d/n", LOAD_INT(a), LOAD_FRAC(a), LOAD_INT(b), LOAD_FRAC(b), LOAD_INT(c), LOAD_FRAC(c));    printk(KERN_INFO "Total usable main memory size: %lu/n", (kk.totalram)*(unsigned long long)kk.mem_unit/1048576);    printk(KERN_INFO "Available memory size: %lu/n", (kk.freeram)*(unsigned long long)kk.mem_unit/1048576);    printk(KERN_INFO "Number of current processes: %u/n", (kk.procs));		    /* verify that we actually have some data to write */    if (count == 0)            goto exit;    /* create a urb, and a buffer for it, and copy the data to the urb */    urb = usb_alloc_urb(0, GFP_KERNEL);    if (!urb) {            retval = -ENOMEM;            goto error;    }    buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);    if (!buf) {            retval = -ENOMEM;            goto error;    }    //Dummy data    printk("load %d/n",LOAD_INT(a)*100+LOAD_FRAC(a));    //(kk.totalram)*((unsigned long long)kk.mem_unit/1048576)    printk("mem %d/n",((kk.totalram)*(unsigned long long)kk.mem_unit/1048576));    printk("mem %d/n",(100-((kk.freeram)*(unsigned long long)kk.mem_unit/1048576)*100/((kk.totalram)*(unsigned long long)kk.mem_unit/1048576)));    buf[0]='R';    buf[1]='a';//(int16_t)(avenrun[0] << (SI_LOAD_SHIFT - FSHIFT)*100);    buf[2]=(char)(LOAD_INT(a)*100+LOAD_FRAC(a));    buf[3]=(char)(100-((kk.freeram)*(unsigned long long)kk.mem_unit/1048576)*100/((kk.totalram)*(unsigned long long)kk.mem_unit/1048576));//hours;    buf[4]='l';    printk("WRITE LOKA: buffer:/n");    int i;    for (i= 0; i < 5; ++i)    {    	printk("%d - %c (%d)/n",buf[i],buf[i],i);    }    /* initialize the urb properly */    usb_fill_bulk_urb(urb, dev->udev,                      usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),                      buf, count, proto_write_bulk_callback, dev);    urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;    /* send the data out the bulk port */    retval = usb_submit_urb(urb, GFP_KERNEL);    if (retval) {            pr_err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);            goto error;    }    /* release our reference to this urb, the USB core will eventually free it entirely */    usb_free_urb(urb);exit:    mod_timer(&timer_write_periodic, jiffies + HZ); /* restarting timer */    return count;error:    usb_free_coherent(dev->udev, count, buf, urb->transfer_dma);//.........这里部分代码省略.........

static int bcm5974_probe(struct usb_interface *iface,			 const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(iface);	const struct bcm5974_config *cfg;	struct bcm5974 *dev;	struct input_dev *input_dev;	int error = -ENOMEM;	/* find the product index */	cfg = bcm5974_get_config(udev);	/* allocate memory for our device state and initialize it */	dev = kzalloc(sizeof(struct bcm5974), GFP_KERNEL);	input_dev = input_allocate_device();	if (!dev || !input_dev) {		dev_err(&iface->dev, "out of memory/n");		goto err_free_devs;	}	dev->udev = udev;	dev->intf = iface;	dev->input = input_dev;	dev->cfg = *cfg;	mutex_init(&dev->pm_mutex);	/* setup urbs */	if (cfg->tp_type == TYPE1) {		dev->bt_urb = usb_alloc_urb(0, GFP_KERNEL);		if (!dev->bt_urb)			goto err_free_devs;	}	dev->tp_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->tp_urb)		goto err_free_bt_urb;	if (dev->bt_urb) {		dev->bt_data = usb_alloc_coherent(dev->udev,					  dev->cfg.bt_datalen, GFP_KERNEL,					  &dev->bt_urb->transfer_dma);		if (!dev->bt_data)			goto err_free_urb;	}	dev->tp_data = usb_alloc_coherent(dev->udev,					  dev->cfg.tp_datalen, GFP_KERNEL,					  &dev->tp_urb->transfer_dma);	if (!dev->tp_data)		goto err_free_bt_buffer;	if (dev->bt_urb)		usb_fill_int_urb(dev->bt_urb, udev,				 usb_rcvintpipe(udev, cfg->bt_ep),				 dev->bt_data, dev->cfg.bt_datalen,				 bcm5974_irq_button, dev, 1);	usb_fill_int_urb(dev->tp_urb, udev,			 usb_rcvintpipe(udev, cfg->tp_ep),			 dev->tp_data, dev->cfg.tp_datalen,			 bcm5974_irq_trackpad, dev, 1);	/* create bcm5974 device */	usb_make_path(udev, dev->phys, sizeof(dev->phys));	strlcat(dev->phys, "/input0", sizeof(dev->phys));	input_dev->name = "bcm5974";	input_dev->phys = dev->phys;	usb_to_input_id(dev->udev, &input_dev->id);	/* report driver capabilities via the version field */	input_dev->id.version = cfg->caps;	input_dev->dev.parent = &iface->dev;	input_set_drvdata(input_dev, dev);	input_dev->open = bcm5974_open;	input_dev->close = bcm5974_close;	setup_events_to_report(input_dev, cfg);	error = input_register_device(dev->input);	if (error)		goto err_free_buffer;	/* save our data pointer in this interface device */	usb_set_intfdata(iface, dev);	return 0;err_free_buffer:	usb_free_coherent(dev->udev, dev->cfg.tp_datalen,		dev->tp_data, dev->tp_urb->transfer_dma);err_free_bt_buffer:	if (dev->bt_urb)		usb_free_coherent(dev->udev, dev->cfg.bt_datalen,				  dev->bt_data, dev->bt_urb->transfer_dma);err_free_urb:	usb_free_urb(dev->tp_urb);err_free_bt_urb:	usb_free_urb(dev->bt_urb);//.........这里部分代码省略.........

static netdev_tx_t gs_can_start_xmit(struct sk_buff *skb,				     struct net_device *netdev){	struct gs_can *dev = netdev_priv(netdev);	struct net_device_stats *stats = &dev->netdev->stats;	struct urb *urb;	struct gs_host_frame *hf;	struct can_frame *cf;	int rc;	unsigned int idx;	struct gs_tx_context *txc;	if (can_dropped_invalid_skb(netdev, skb))		return NETDEV_TX_OK;	/* find an empty context to keep track of transmission */	txc = gs_alloc_tx_context(dev);	if (!txc)		return NETDEV_TX_BUSY;	/* create a URB, and a buffer for it */	urb = usb_alloc_urb(0, GFP_ATOMIC);	if (!urb)		goto nomem_urb;	hf = usb_alloc_coherent(dev->udev, sizeof(*hf), GFP_ATOMIC,				&urb->transfer_dma);	if (!hf) {		netdev_err(netdev, "No memory left for USB buffer/n");		goto nomem_hf;	}	idx = txc->echo_id;	if (idx >= GS_MAX_TX_URBS) {		netdev_err(netdev, "Invalid tx context %d/n", idx);		goto badidx;	}	hf->echo_id = idx;	hf->channel = dev->channel;	cf = (struct can_frame *)skb->data;	hf->can_id = cf->can_id;	hf->can_dlc = cf->can_dlc;	memcpy(hf->data, cf->data, cf->can_dlc);	usb_fill_bulk_urb(urb, dev->udev,			  usb_sndbulkpipe(dev->udev, GSUSB_ENDPOINT_OUT),			  hf,			  sizeof(*hf),			  gs_usb_xmit_callback,			  txc);	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	usb_anchor_urb(urb, &dev->tx_submitted);	can_put_echo_skb(skb, netdev, idx);	atomic_inc(&dev->active_tx_urbs);	rc = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(rc)) {			/* usb send failed */		atomic_dec(&dev->active_tx_urbs);		can_free_echo_skb(netdev, idx);		gs_free_tx_context(txc);		usb_unanchor_urb(urb);		usb_free_coherent(dev->udev,				  sizeof(*hf),				  hf,				  urb->transfer_dma);		if (rc == -ENODEV) {			netif_device_detach(netdev);		} else {			netdev_err(netdev, "usb_submit failed (err=%d)/n", rc);			stats->tx_dropped++;		}	} else {		/* Slow down tx path */		if (atomic_read(&dev->active_tx_urbs) >= GS_MAX_TX_URBS)			netif_stop_queue(netdev);	}	/* let usb core take care of this urb */	usb_free_urb(urb);	return NETDEV_TX_OK; badidx:	usb_free_coherent(dev->udev,			  sizeof(*hf),			  hf,			  urb->transfer_dma); nomem_hf:	usb_free_urb(urb);//.........这里部分代码省略.........

//.........这里部分代码省略.........	default:		break;	}resubmit:	usb_anchor_urb(_urb, &rtlusb->rx_submitted);	err = usb_submit_urb(_urb, GFP_ATOMIC);	if (unlikely(err)) {		usb_unanchor_urb(_urb);		goto free;	}	return;free:	/* On some architectures, usb_free_coherent must not be called from	 * hardirq context. Queue urb to cleanup list.	 */	usb_anchor_urb(_urb, &rtlusb->rx_cleanup_urbs);}#undef __RADIO_TAP_SIZE_RSVstatic void _rtl_usb_cleanup_rx(struct ieee80211_hw *hw){	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));	struct urb *urb;	usb_kill_anchored_urbs(&rtlusb->rx_submitted);	tasklet_kill(&rtlusb->rx_work_tasklet);	skb_queue_purge(&rtlusb->rx_queue);	while ((urb = usb_get_from_anchor(&rtlusb->rx_cleanup_urbs))) {		usb_free_coherent(urb->dev, urb->transfer_buffer_length,				urb->transfer_buffer, urb->transfer_dma);		usb_free_urb(urb);	}}static int _rtl_usb_receive(struct ieee80211_hw *hw){	struct urb *urb;	int err;	int i;	struct rtl_priv *rtlpriv = rtl_priv(hw);	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));	WARN_ON(0 == rtlusb->rx_urb_num);	/* 1600 == 1514 + max WLAN header + rtk info */	WARN_ON(rtlusb->rx_max_size < 1600);	for (i = 0; i < rtlusb->rx_urb_num; i++) {		err = -ENOMEM;		urb = usb_alloc_urb(0, GFP_KERNEL);		if (!urb) {			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,				 "Failed to alloc URB!!/n");			goto err_out;		}		err = _rtl_prep_rx_urb(hw, rtlusb, urb, GFP_KERNEL);		if (err < 0) {			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,				 "Failed to prep_rx_urb!!/n");			usb_free_urb(urb);			goto err_out;

static int __devinit iguanair_probe(struct usb_interface *intf,						const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(intf);	struct iguanair *ir;	struct rc_dev *rc;	int ret;	struct usb_host_interface *idesc;	ir = kzalloc(sizeof(*ir), GFP_KERNEL);	rc = rc_allocate_device();	if (!ir || !rc) {		ret = ENOMEM;		goto out;	}	ir->buf_in = usb_alloc_coherent(udev, MAX_PACKET_SIZE, GFP_ATOMIC,								&ir->dma_in);	ir->urb_in = usb_alloc_urb(0, GFP_KERNEL);	if (!ir->buf_in || !ir->urb_in) {		ret = ENOMEM;		goto out;	}	idesc = intf->altsetting;	if (idesc->desc.bNumEndpoints < 2) {		ret = -ENODEV;		goto out;	}	ir->rc = rc;	ir->dev = &intf->dev;	ir->udev = udev;	ir->pipe_in = usb_rcvintpipe(udev,				idesc->endpoint[0].desc.bEndpointAddress);	ir->pipe_out = usb_sndintpipe(udev,				idesc->endpoint[1].desc.bEndpointAddress);	mutex_init(&ir->lock);	init_completion(&ir->completion);	ret = iguanair_get_features(ir);	if (ret) {		dev_warn(&intf->dev, "failed to get device features");		goto out;	}	usb_fill_int_urb(ir->urb_in, ir->udev, ir->pipe_in, ir->buf_in,		MAX_PACKET_SIZE, iguanair_rx, ir,		idesc->endpoint[0].desc.bInterval);	ir->urb_in->transfer_dma = ir->dma_in;	ir->urb_in->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	snprintf(ir->name, sizeof(ir->name),		"IguanaWorks USB IR Transceiver version %d.%d",		ir->version[0], ir->version[1]);	usb_make_path(ir->udev, ir->phys, sizeof(ir->phys));	rc->input_name = ir->name;	rc->input_phys = ir->phys;	usb_to_input_id(ir->udev, &rc->input_id);	rc->dev.parent = &intf->dev;	rc->driver_type = RC_DRIVER_IR_RAW;	rc->allowed_protos = RC_TYPE_ALL;	rc->priv = ir;	rc->open = iguanair_open;	rc->close = iguanair_close;	rc->s_tx_mask = iguanair_set_tx_mask;	rc->s_tx_carrier = iguanair_set_tx_carrier;	rc->tx_ir = iguanair_tx;	rc->driver_name = DRIVER_NAME;	rc->map_name = RC_MAP_EMPTY;	iguanair_set_tx_carrier(rc, 38000);	ret = rc_register_device(rc);	if (ret < 0) {		dev_err(&intf->dev, "failed to register rc device %d", ret);		goto out;	}	usb_set_intfdata(intf, ir);	dev_info(&intf->dev, "Registered %s", ir->name);	return 0;out:	if (ir) {		usb_free_urb(ir->urb_in);		usb_free_coherent(udev, MAX_PACKET_SIZE, ir->buf_in,								ir->dma_in);	}	rc_free_device(rc);	kfree(ir);	return ret;}