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

//.........这里部分代码省略.........	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);	/* Allocate buffer for control messages */	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;	}	/* Allocate interrupt URB */	pdata->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!pdata->urb) {		retval = -ENOMEM;		dev_err(&iface->dev, "Allocating URB failed/n");		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);	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_unchecked(&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 (pdata->bd && !IS_ERR(pdata->bd))			backlight_device_unregister(pdata->bd);		kfree(pdata->msgdata);	}	usb_set_intfdata(iface, NULL);	kfree(pdata);	return retval;}

static void f81232_close(struct usb_serial_port *port){	usb_serial_generic_close(port);	usb_kill_urb(port->interrupt_in_urb);}

static int acm_port_activate(struct tty_port *port, struct tty_struct *tty){	struct acm *acm = container_of(port, struct acm, port);	int retval = -ENODEV;	int i;	dev_dbg(&acm->control->dev, "%s/n", __func__);	mutex_lock(&acm->mutex);	if (acm->disconnected)		goto disconnected;	retval = usb_autopm_get_interface(acm->control);	if (retval)		goto error_get_interface;	/*	 * FIXME: Why do we need this? Allocating 64K of physically contiguous	 * memory is really nasty...	 */	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);	acm->control->needs_remote_wakeup = 1;	acm->ctrlurb->dev = acm->dev;	if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {		dev_err(&acm->control->dev,			"%s - usb_submit_urb(ctrl irq) failed/n", __func__);		goto error_submit_urb;	}	acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;	if (acm_set_control(acm, acm->ctrlout) < 0 &&	    (acm->ctrl_caps & USB_CDC_CAP_LINE))		goto error_set_control;	usb_autopm_put_interface(acm->control);	/*	 * Unthrottle device in case the TTY was closed while throttled.	 */	spin_lock_irq(&acm->read_lock);	acm->throttled = 0;	acm->throttle_req = 0;	spin_unlock_irq(&acm->read_lock);	if (acm_submit_read_urbs(acm, GFP_KERNEL))		goto error_submit_read_urbs;	mutex_unlock(&acm->mutex);	return 0;error_submit_read_urbs:	for (i = 0; i < acm->rx_buflimit; i++)		usb_kill_urb(acm->read_urbs[i]);	acm->ctrlout = 0;	acm_set_control(acm, acm->ctrlout);error_set_control:	usb_kill_urb(acm->ctrlurb);error_submit_urb:	usb_autopm_put_interface(acm->control);error_get_interface:disconnected:	mutex_unlock(&acm->mutex);	return retval;}

static void pvr2_buffer_wipe(struct pvr2_buffer *bp){	if (bp->state == pvr2_buffer_state_queued) {		usb_kill_urb(bp->purb);	}}

static inline void stop_urb(struct urb *urb){	if (urb && urb->status == -EINPROGRESS)		usb_kill_urb(urb);}

static int baseband_usb_driver_suspend(struct usb_interface *intf,	pm_message_t message){	int i, susp_count, j;	pr_debug("%s intf %p/n", __func__, intf);#ifdef CONFIG_PM_RUNTIME	pr_debug("%s: cnt %d intf=%p &intf->dev=%p kobj=%s/n",			__func__, atomic_read(&intf->dev.power.usage_count),			intf, &intf->dev, kobject_name(&intf->dev.kobj));#endif	for (i = 0; i < max_intfs; i++) {		pr_debug("[%d]/n", i);		if (!baseband_usb_net[i])			continue;		if (baseband_usb_net[i]->usb.interface != intf) {			pr_debug("%p != %p/n",				baseband_usb_net[i]->usb.interface, intf);			continue;		}		/* increment suspend count */		susp_count = (baseband_usb_net[i]->susp_count)++;		if (susp_count > 0) {			pr_debug("%s: susp_count %d > 0 (already suspended)/n",				__func__, susp_count);			continue;		}		if (susp_count < 0) {			pr_debug("%s: susp_count %d < 0 (ILLEGAL VALUE)/n",				__func__, susp_count);			baseband_usb_net[i]->susp_count = 0;			continue;		}		pr_debug("%s: susp_count = %d (suspending...)/n",			__func__, susp_count);		/* acquire semaphore */		if (down_interruptible(&baseband_usb_net[i]->sem)) {			pr_err("%s: cannot acquire semaphore/n", __func__);			continue;		}		/* kill usb rx */		pr_debug("%s: kill rx_urb {/n",__func__);		for (j = 0; j < RAWIP_RX_BUFS; j++)			usb_kill_urb(baseband_usb_net[i]->urb_r[j]);		pr_debug("%s: kill rx_urb }/n",__func__);		baseband_usb_net[i]->usb.rx_urb = (struct urb *) 0;		/* cancel tx urb work (will restart after resume) */		if (!baseband_usb_net[i]->usb.tx_workqueue) {			pr_err("%s: !tx_workqueue/n", __func__);			up(&baseband_usb_net[i]->sem);			continue;		}		pr_debug("%s: cancel_work_sync {/n",__func__);		cancel_work_sync(&baseband_usb_net[i]->usb.tx_work);		pr_debug("%s: cancel_work_sync }/n",__func__);		/* release semaphore */		up(&baseband_usb_net[i]->sem);	}	return 0;}

static void ar5523_cancel_rx_cmd(struct ar5523 *ar){	usb_kill_urb(ar->rx_cmd_urb);}

static int usb_net_raw_ip_init(void){	int i, j;	int err;	char name[32];	pr_debug("usb_net_raw_ip_init { max_intfs %d/n", max_intfs);	err = usb_register(&baseband_usb_driver);	if (err < 0) {		pr_err("cannot open usb driver - err %d/n", err);		return err;	}	/* create multiple raw-ip network devices */	for (i = 0; i < max_intfs; i++) {		/* open baseband usb */		g_i = i;		baseband_usb_net[i] = baseband_usb_open(i,						usb_net_raw_ip_intf[i]);		if (!baseband_usb_net[i]) {			pr_err("cannot open baseband usb net/n");			err = -1;			goto error_exit;		}		init_usb_anchor(&baseband_usb_net[i]->usb.tx_urb_deferred);		/* register network device */		usb_net_raw_ip_dev[i] = alloc_netdev(0,			BASEBAND_USB_NET_DEV_NAME,			ether_setup);		if (!usb_net_raw_ip_dev[i]) {			pr_err("alloc_netdev() failed/n");			err = -ENOMEM;			goto error_exit;		}		usb_net_raw_ip_dev[i]->netdev_ops = &usb_net_raw_ip_ops;		usb_net_raw_ip_dev[i]->watchdog_timeo = TX_TIMEOUT;		random_ether_addr(usb_net_raw_ip_dev[i]->dev_addr);		err = register_netdev(usb_net_raw_ip_dev[i]);		if (err < 0) {			pr_err("cannot register network device - %d/n", err);			goto error_exit;		}		pr_debug("registered baseband usb network device"				" - dev %p name %s/n", usb_net_raw_ip_dev[i],				 BASEBAND_USB_NET_DEV_NAME);		/* start usb rx */		err = usb_net_raw_ip_setup_rx_urb(baseband_usb_net[i]);		if (err < 0) {			pr_err("setup reusable rx urb failed - err %d/n", err);			goto error_exit;		}		err = usb_net_raw_ip_rx_urb_submit(baseband_usb_net[i]);		if (err < 0) {			pr_err("submit rx failed - err %d/n", err);			goto error_exit;		}		/* start usb tx */		sprintf(name, "raw_ip_tx_wq-%d",			baseband_usb_net[i]->baseband_index);		baseband_usb_net[i]->usb.tx_workqueue			= create_singlethread_workqueue(name);		if (!baseband_usb_net[i]->usb.tx_workqueue) {			pr_err("cannot create workqueue/n");			goto error_exit;		}		INIT_WORK(&baseband_usb_net[i]->usb.tx_work,			usb_net_raw_ip_tx_urb_work);	}	pr_debug("usb_net_raw_ip_init }/n");	return 0;error_exit:	/* destroy multiple raw-ip network devices */	for (i = 0; i < max_intfs; i++) {		/* unregister network device */		if (usb_net_raw_ip_dev[i]) {			unregister_netdev(usb_net_raw_ip_dev[i]);			free_netdev(usb_net_raw_ip_dev[i]);			usb_net_raw_ip_dev[i] = (struct net_device *) 0;		}		/* close baseband usb */		if (baseband_usb_net[i]) {			/* stop usb tx */			if (baseband_usb_net[i]->usb.tx_workqueue) {				destroy_workqueue(baseband_usb_net[i]					->usb.tx_workqueue);				baseband_usb_net[i]->usb.tx_workqueue					= (struct workqueue_struct *) 0;			}			if (baseband_usb_net[i]->usb.tx_urb) {				usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);				baseband_usb_net[i]->usb.tx_urb					= (struct urb *) 0;			}			/* stop usb rx */			for (j = 0; j < RAWIP_RX_BUFS; j++)				if (baseband_usb_net[i]->urb_r[j])//.........这里部分代码省略.........

static void usb_net_raw_ip_exit(void){	struct baseband_usb *usb;	int i, j;	pr_debug("usb_net_raw_ip_exit {/n");	/* destroy multiple raw-ip network devices */	for (i = 0; i < max_intfs; i++) {		usb = baseband_usb_net[i];		/* stop baseband usb urbs */		if (usb) {			if (usb->usb.interface)				usb_autopm_get_interface(usb->usb.interface);			if (usb->usb.tx_workqueue)				cancel_work_sync(&usb->usb.tx_work);			/* stop usb tx */			pr_debug("%s: kill tx urb/n", __func__);			if (usb->usb.tx_urb) {				usb_kill_urb(usb->usb.tx_urb);				usb->usb.tx_urb = NULL;			}			/* stop usb rx */			pr_debug("%s: kill rx urbs/n", __func__);			for (j = 0; j < RAWIP_RX_BUFS; j++) {				if (usb->urb_r[j])					usb_kill_urb(usb->urb_r[j]);			}			usb_net_raw_ip_free_rx_urb(usb);			if (usb->usb.interface)				usb_autopm_put_interface(usb->usb.interface);		}		pr_debug("%s: unregister netdev/n", __func__);		/* unregister network device */		if (usb_net_raw_ip_dev[i]) {			unregister_netdev(usb_net_raw_ip_dev[i]);			free_netdev(usb_net_raw_ip_dev[i]);			usb_net_raw_ip_dev[i] = (struct net_device *) 0;		}		if (usb) {			pr_debug("%s: destroy tx workqueue/n", __func__);			if (usb->usb.tx_workqueue) {				destroy_workqueue(usb->usb.tx_workqueue);				usb->usb.tx_workqueue = NULL;			}			/* close usb */			baseband_usb_close(usb);			baseband_usb_net[i] = NULL;		}	}	pr_debug("close usb driver {/n");	usb_deregister(&baseband_usb_driver);	pr_debug("close usb driver }/n");	pr_debug("usb_net_raw_ip_exit }/n");}

/* * Read an ack from  the notification endpoint * * @i2400m: * @_ack: pointer to where to store the read data * @ack_size: how many bytes we should read * * Returns: < 0 errno code on error; otherwise, amount of received bytes. * * Submits a notification read, appends the read data to the given ack * buffer and then repeats (until @ack_size bytes have been * received). */ssize_t i2400mu_bus_bm_wait_for_ack(struct i2400m *i2400m,				    struct i2400m_bootrom_header *_ack,				    size_t ack_size){	ssize_t result = -ENOMEM;	struct device *dev = i2400m_dev(i2400m);	struct i2400mu *i2400mu = container_of(i2400m, struct i2400mu, i2400m);	struct urb notif_urb;	void *ack = _ack;	size_t offset, len;	long val;	int do_autopm = 1;	DECLARE_COMPLETION_ONSTACK(notif_completion);	d_fnstart(8, dev, "(i2400m %p ack %p size %zu)/n",		  i2400m, ack, ack_size);	BUG_ON(_ack == i2400m->bm_ack_buf);	result = usb_autopm_get_interface(i2400mu->usb_iface);	if (result < 0) {		dev_err(dev, "BM-ACK: can't get autopm: %d/n", (int) result);		do_autopm = 0;	}	usb_init_urb(&notif_urb);	/* ready notifications */	usb_get_urb(&notif_urb);	offset = 0;	while (offset < ack_size) {		init_completion(&notif_completion);		result = i2400mu_notif_submit(i2400mu, &notif_urb,					      &notif_completion);		if (result < 0)			goto error_notif_urb_submit;		val = wait_for_completion_interruptible_timeout(			&notif_completion, HZ);		if (val == 0) {			result = -ETIMEDOUT;			usb_kill_urb(&notif_urb);	/* Timedout */			goto error_notif_wait;		}		if (val == -ERESTARTSYS) {			result = -EINTR;		/* Interrupted */			usb_kill_urb(&notif_urb);			goto error_notif_wait;		}		result = notif_urb.status;		/* How was the ack? */		switch (result) {		case 0:			break;		case -EINVAL:			/* while removing driver */		case -ENODEV:			/* dev disconnect ... */		case -ENOENT:			/* just ignore it */		case -ESHUTDOWN:		/* and exit */		case -ECONNRESET:			result = -ESHUTDOWN;			goto error_dev_gone;		default:				/* any other? */			usb_kill_urb(&notif_urb);	/* Timedout */			if (edc_inc(&i2400mu->urb_edc,				    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))				goto error_exceeded;			dev_err(dev, "BM-ACK: URB error %d, "				"retrying/n", notif_urb.status);			continue;	/* retry */		}		if (notif_urb.actual_length == 0) {			d_printf(6, dev, "ZLP received, retrying/n");			continue;		}		/* Got data, append it to the buffer */		len = min(ack_size - offset, (size_t) notif_urb.actual_length);		memcpy(ack + offset, i2400m->bm_ack_buf, len);		offset += len;	}	result = offset;error_notif_urb_submit:error_notif_wait:error_dev_gone:out:	if (do_autopm)		usb_autopm_put_interface(i2400mu->usb_iface);	d_fnend(8, dev, "(i2400m %p ack %p size %zu) = %ld/n",		i2400m, ack, ack_size, (long) result);	return result;error_exceeded:	dev_err(dev, "bm: maximum errors in notification URB exceeded; "		"resetting device/n");	usb_queue_reset_device(i2400mu->usb_iface);//.........这里部分代码省略.........

static void xpad_stop_output(struct usb_xpad *xpad) //清空 out型 urb 的数据{    usb_kill_urb(xpad->irq_out);}

static void ipheth_kill_urbs(struct ipheth_device *dev){	usb_kill_urb(dev->tx_urb);	usb_kill_urb(dev->rx_urb);}

void x52_close (struct input_dev *idev){    struct x52_joy *joy = input_get_drvdata(idev);    usb_kill_urb(joy->irq_in);}

static void omninet_close(struct usb_serial_port *port){	dbg("%s - port %d", __func__, port->number);	usb_kill_urb(port->read_urb);}

void ctrl_bridge_stop_read(struct ctrl_bridge *dev){	usb_kill_urb(dev->readurb);	usb_kill_urb(dev->inturb);}

static int acm_tty_open(struct tty_struct *tty, struct file *filp){	struct acm *acm;	int rv = -ENODEV;	int i;	dbg("Entering acm_tty_open.");	mutex_lock(&open_mutex);	acm = acm_table[tty->index];	if (!acm || !acm->dev)		goto err_out;	else		rv = 0;	set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);	tty->driver_data = acm;	tty_port_tty_set(&acm->port, tty);	if (usb_autopm_get_interface(acm->control) < 0)		goto early_bail;	else		acm->control->needs_remote_wakeup = 1;	mutex_lock(&acm->mutex);	if (acm->port.count++) {		usb_autopm_put_interface(acm->control);		goto done;	}	acm->ctrlurb->dev = acm->dev;	if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {		dbg("usb_submit_urb(ctrl irq) failed");		goto bail_out;	}	if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&	    (acm->ctrl_caps & USB_CDC_CAP_LINE))		goto full_bailout;	usb_autopm_put_interface(acm->control);	INIT_LIST_HEAD(&acm->spare_read_urbs);	INIT_LIST_HEAD(&acm->spare_read_bufs);	INIT_LIST_HEAD(&acm->filled_read_bufs);	for (i = 0; i < acm->rx_buflimit; i++)		list_add(&(acm->ru[i].list), &acm->spare_read_urbs);	for (i = 0; i < acm->rx_buflimit; i++)		list_add(&(acm->rb[i].list), &acm->spare_read_bufs);	acm->throttle = 0;	set_bit(ASYNCB_INITIALIZED, &acm->port.flags);	rv = tty_port_block_til_ready(&acm->port, tty, filp);	tasklet_schedule(&acm->urb_task);done:	mutex_unlock(&acm->mutex);err_out:	mutex_unlock(&open_mutex);	return rv;full_bailout:	usb_kill_urb(acm->ctrlurb);bail_out:	usb_autopm_put_interface(acm->control);	acm->port.count--;	mutex_unlock(&acm->mutex);early_bail:	mutex_unlock(&open_mutex);	tty_port_tty_set(&acm->port, NULL);	return -EIO;}

static inline void mts_urb_abort(struct mts_desc* desc) {	MTS_DEBUG_GOT_HERE();	mts_debug_dump(desc);	usb_kill_urb( desc->urb );}

static void omninet_close(struct tty_struct *tty,			struct usb_serial_port *port, struct file *filp){	dbg("%s - port %d", __func__, port->number);	usb_kill_urb(port->read_urb);}

void free_urb(struct urb *urb){   usb_kill_urb(urb);   kfree(urb->transfer_buffer);   usb_free_urb(urb);}

static void xpad_stop_output(struct usb_xpad *xpad){	usb_kill_urb(xpad->irq_out);}

/* This is the common part of the URB message submission code * * All URBs from the usb-storage driver involved in handling a queued scsi * command _must_ pass through this function (or something like it) for the * abort mechanisms to work properly. */static int usb_stor_msg_common(struct us_data *us, int timeout){	struct completion urb_done;	long timeleft;	int status;	/* don't submit URBs during abort processing */	if (test_bit(US_FLIDX_ABORTING, &us->dflags))		return -EIO;	/* set up data structures for the wakeup system */	init_completion(&urb_done);	/* fill the common fields in the URB */	us->current_urb->context = &urb_done;	us->current_urb->actual_length = 0;	us->current_urb->error_count = 0;	us->current_urb->status = 0;	/* we assume that if transfer_buffer isn't us->iobuf then it	 * hasn't been mapped for DMA.  Yes, this is clunky, but it's	 * easier than always having the caller tell us whether the	 * transfer buffer has already been mapped. */	us->current_urb->transfer_flags = URB_NO_SETUP_DMA_MAP;	if (us->current_urb->transfer_buffer == us->iobuf)		us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;	us->current_urb->transfer_dma = us->iobuf_dma;	us->current_urb->setup_dma = us->cr_dma;	/* submit the URB */	status = usb_submit_urb(us->current_urb, GFP_NOIO);	if (status) {		/* something went wrong */		return status;	}	/* since the URB has been submitted successfully, it's now okay	 * to cancel it */	set_bit(US_FLIDX_URB_ACTIVE, &us->dflags);	/* did an abort occur during the submission? */	if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {		/* cancel the URB, if it hasn't been cancelled already */		if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags)) {			US_DEBUGP("-- cancelling URB/n");			usb_unlink_urb(us->current_urb);		}	} 	/* wait for the completion of the URB */	timeleft = wait_for_completion_interruptible_timeout(			&urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT); 	clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags);	if (timeleft <= 0) {		US_DEBUGP("%s -- cancelling URB/n",			  timeleft == 0 ? "Timeout" : "Signal");		usb_kill_urb(us->current_urb);	}	/* return the URB status */	return us->current_urb->status;}

static int  mct_u232_open (struct usb_serial_port *port, struct file *filp){	struct usb_serial *serial = port->serial;	struct mct_u232_private *priv = usb_get_serial_port_data(port);	int retval = 0;	unsigned int control_state;	unsigned long flags;	unsigned char last_lcr;	unsigned char last_msr;	dbg("%s port %d", __FUNCTION__, port->number);	/* Compensate for a hardware bug: although the Sitecom U232-P25	 * device reports a maximum output packet size of 32 bytes,	 * it seems to be able to accept only 16 bytes (and that's what	 * SniffUSB says too...)	 */	if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID)		port->bulk_out_size = 16;	/* Do a defined restart: the normal serial device seems to 	 * always turn on DTR and RTS here, so do the same. I'm not	 * sure if this is really necessary. But it should not harm	 * either.	 */	spin_lock_irqsave(&priv->lock, flags);	if (port->tty->termios->c_cflag & CBAUD)		priv->control_state = TIOCM_DTR | TIOCM_RTS;	else		priv->control_state = 0;		priv->last_lcr = (MCT_U232_DATA_BITS_8 | 			  MCT_U232_PARITY_NONE |			  MCT_U232_STOP_BITS_1);	control_state = priv->control_state;	last_lcr = priv->last_lcr;	spin_unlock_irqrestore(&priv->lock, flags);	mct_u232_set_modem_ctrl(serial, control_state);	mct_u232_set_line_ctrl(serial, last_lcr);	/* Read modem status and update control state */	mct_u232_get_modem_stat(serial, &last_msr);	spin_lock_irqsave(&priv->lock, flags);	priv->last_msr = last_msr;	mct_u232_msr_to_state(&priv->control_state, priv->last_msr);	spin_unlock_irqrestore(&priv->lock, flags);	port->read_urb->dev = port->serial->dev;	retval = usb_submit_urb(port->read_urb, GFP_KERNEL);	if (retval) {		err("usb_submit_urb(read bulk) failed pipe 0x%x err %d",		    port->read_urb->pipe, retval);		goto error;	}	port->interrupt_in_urb->dev = port->serial->dev;	retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);	if (retval) {		usb_kill_urb(port->read_urb);		err(" usb_submit_urb(read int) failed pipe 0x%x err %d",		    port->interrupt_in_urb->pipe, retval);		goto error;	}	return 0;error:	return retval;} /* mct_u232_open */

static void navman_close(struct usb_serial_port *port){	dbg("%s - port %d", __func__, port->number);	usb_kill_urb(port->interrupt_in_urb);}

static void qt2_disconnect(struct usb_serial *serial){	struct qt2_serial_private *serial_priv = usb_get_serial_data(serial);	usb_kill_urb(serial_priv->read_urb);}

static void kbtab_close(struct input_dev *dev){	struct kbtab *kbtab = input_get_drvdata(dev);	usb_kill_urb(kbtab->irq);}

static void bcm5974_pause_traffic(struct bcm5974 *dev){	usb_kill_urb(dev->tp_urb);	usb_kill_urb(dev->bt_urb);	bcm5974_wellspring_mode(dev, false);}

//.........这里部分代码省略.........	dev_info(&udev->dev, "%s: Device matched ... !/n", __func__);	cs = gigaset_getunassignedcs(driver);	if (!cs) {		dev_warn(&udev->dev, "no free cardstate/n");		return -ENODEV;	}	ucs = cs->hw.usb;	/* save off device structure ptrs for later use */	usb_get_dev(udev);	ucs->udev = udev;	ucs->interface = interface;	cs->dev = &interface->dev;	/* save address of controller structure */	usb_set_intfdata(interface, cs); // dev_set_drvdata(&interface->dev, cs);	endpoint = &hostif->endpoint[0].desc;	buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);	ucs->bulk_out_size = buffer_size;	ucs->bulk_out_endpointAddr = endpoint->bEndpointAddress;	ucs->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);	if (!ucs->bulk_out_buffer) {		dev_err(cs->dev, "Couldn't allocate bulk_out_buffer/n");		retval = -ENOMEM;		goto error;	}	ucs->bulk_out_urb = usb_alloc_urb(0, SLAB_KERNEL);	if (!ucs->bulk_out_urb) {		dev_err(cs->dev, "Couldn't allocate bulk_out_urb/n");		retval = -ENOMEM;		goto error;	}	endpoint = &hostif->endpoint[1].desc;	atomic_set(&ucs->busy, 0);	ucs->read_urb = usb_alloc_urb(0, SLAB_KERNEL);	if (!ucs->read_urb) {		dev_err(cs->dev, "No free urbs available/n");		retval = -ENOMEM;		goto error;	}	buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);	ucs->rcvbuf_size = buffer_size;	ucs->int_in_endpointAddr = endpoint->bEndpointAddress;	cs->inbuf[0].rcvbuf = kmalloc(buffer_size, GFP_KERNEL);	if (!cs->inbuf[0].rcvbuf) {		dev_err(cs->dev, "Couldn't allocate rcvbuf/n");		retval = -ENOMEM;		goto error;	}	/* Fill the interrupt urb and send it to the core */	usb_fill_int_urb(ucs->read_urb, udev,			 usb_rcvintpipe(udev,					endpoint->bEndpointAddress & 0x0f),			 cs->inbuf[0].rcvbuf, buffer_size,			 gigaset_read_int_callback,			 cs->inbuf + 0, endpoint->bInterval);	retval = usb_submit_urb(ucs->read_urb, SLAB_KERNEL);	if (retval) {		dev_err(cs->dev, "Could not submit URB (error %d)/n", -retval);		goto error;	}	/* tell common part that the device is ready */	if (startmode == SM_LOCKED)		atomic_set(&cs->mstate, MS_LOCKED);	if (!gigaset_start(cs)) {		tasklet_kill(&cs->write_tasklet);		retval = -ENODEV; //FIXME		goto error;	}	return 0;error:	if (ucs->read_urb)		usb_kill_urb(ucs->read_urb);	kfree(ucs->bulk_out_buffer);	if (ucs->bulk_out_urb != NULL)		usb_free_urb(ucs->bulk_out_urb);	kfree(cs->inbuf[0].rcvbuf);	if (ucs->read_urb != NULL)		usb_free_urb(ucs->read_urb);	usb_set_intfdata(interface, NULL);	ucs->read_urb = ucs->bulk_out_urb = NULL;	cs->inbuf[0].rcvbuf = ucs->bulk_out_buffer = NULL;	usb_put_dev(ucs->udev);	ucs->udev = NULL;	ucs->interface = NULL;	gigaset_unassign(cs);	return retval;}