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

staticint i1480u_add(struct i1480u *i1480u, struct usb_interface *iface){	int result = -ENODEV;	struct wlp *wlp = &i1480u->wlp;	struct usb_device *usb_dev = interface_to_usbdev(iface);	struct net_device *net_dev = i1480u->net_dev;	struct uwb_rc *rc;	struct uwb_dev *uwb_dev;#ifdef i1480u_FLOW_CONTROL	struct usb_endpoint_descriptor *epd;#endif	i1480u->usb_dev = usb_get_dev(usb_dev);	i1480u->usb_iface = iface;	rc = uwb_rc_get_by_grandpa(&i1480u->usb_dev->dev);	if (rc == NULL) {		dev_err(&iface->dev, "Cannot get associated UWB Radio "			"Controller/n");		goto out;	}	wlp->xmit_frame = i1480u_xmit_frame;	wlp->fill_device_info = i1480u_fill_device_info;	wlp->stop_queue = i1480u_stop_queue;	wlp->start_queue = i1480u_start_queue;	result = wlp_setup(wlp, rc, net_dev);	if (result < 0) {		dev_err(&iface->dev, "Cannot setup WLP/n");		goto error_wlp_setup;	}	result = 0;	ether_setup(net_dev);			/* make it an etherdevice */	uwb_dev = &rc->uwb_dev;	/* FIXME: hookup address change notifications? */	memcpy(net_dev->dev_addr, uwb_dev->mac_addr.data,	       sizeof(net_dev->dev_addr));	net_dev->hard_header_len = sizeof(struct untd_hdr_cmp)		+ sizeof(struct wlp_tx_hdr)		+ WLP_DATA_HLEN		+ ETH_HLEN;	net_dev->mtu = 3500;	net_dev->tx_queue_len = 20;		/* FIXME: maybe use 1000? *//*	net_dev->flags &= ~IFF_BROADCAST;	FIXME: BUG in firmware */	/* FIXME: multicast disabled */	net_dev->flags &= ~IFF_MULTICAST;	net_dev->features &= ~NETIF_F_SG;	net_dev->features &= ~NETIF_F_FRAGLIST;	/* All NETIF_F_*_CSUM disabled */	net_dev->features |= NETIF_F_HIGHDMA;	net_dev->watchdog_timeo = 5*HZ;		/* FIXME: a better default? */	net_dev->netdev_ops = &i1480u_netdev_ops;#ifdef i1480u_FLOW_CONTROL	/* Notification endpoint setup (submitted when we open the device) */	i1480u->notif_urb = usb_alloc_urb(0, GFP_KERNEL);	if (i1480u->notif_urb == NULL) {		dev_err(&iface->dev, "Unable to allocate notification URB/n");		result = -ENOMEM;		goto error_urb_alloc;	}	epd = &iface->cur_altsetting->endpoint[0].desc;	usb_fill_int_urb(i1480u->notif_urb, usb_dev,			 usb_rcvintpipe(usb_dev, epd->bEndpointAddress),			 i1480u->notif_buffer, sizeof(i1480u->notif_buffer),			 i1480u_notif_cb, i1480u, epd->bInterval);#endif	i1480u->tx_inflight.max = i1480u_TX_INFLIGHT_MAX;	i1480u->tx_inflight.threshold = i1480u_TX_INFLIGHT_THRESHOLD;	i1480u->tx_inflight.restart_ts = jiffies;	usb_set_intfdata(iface, i1480u);	return result;#ifdef i1480u_FLOW_CONTROLerror_urb_alloc:#endif	wlp_remove(wlp);error_wlp_setup:	uwb_rc_put(rc);out:	usb_put_dev(i1480u->usb_dev);	return result;}

static int appledisplay_probe(struct usb_interface *iface,	const struct usb_device_id *id){	struct appledisplay *pdata;	struct usb_device *udev = interface_to_usbdev(iface);	struct usb_host_interface *iface_desc;	struct usb_endpoint_descriptor *endpoint;	int int_in_endpointAddr = 0;	int i, retval = -ENOMEM, brightness;	char bl_name[20];	/* set up the endpoint information */	/* use only the first interrupt-in endpoint */	iface_desc = iface->cur_altsetting;	for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {		endpoint = &iface_desc->endpoint[i].desc;		if (!int_in_endpointAddr && usb_endpoint_is_int_in(endpoint)) {			/* we found an interrupt in endpoint */			int_in_endpointAddr = endpoint->bEndpointAddress;			break;		}	}	if (!int_in_endpointAddr) {		err("Could not find int-in endpoint");		return -EIO;	}	/* allocate memory for our device state and initialize it */	pdata = kzalloc(sizeof(struct appledisplay), GFP_KERNEL);	if (!pdata) {		retval = -ENOMEM;		err("Out of memory");		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;		err("appledisplay: Allocating buffer for control messages "			"failed");		goto error;	}	/* Allocate interrupt URB */	pdata->urb = usb_alloc_urb(0, GFP_KERNEL);	if (!pdata->urb) {		retval = -ENOMEM;		err("appledisplay: Allocating URB failed");		goto error;	}	/* Allocate buffer for interrupt data */	pdata->urbdata = usb_buffer_alloc(pdata->udev, ACD_URB_BUFFER_LEN,		GFP_KERNEL, &pdata->urb->transfer_dma);	if (!pdata->urbdata) {		retval = -ENOMEM;		err("appledisplay: Allocating URB buffer failed");		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;		err("appledisplay: Submitting URB failed");		goto error;	}	/* Register backlight device */	snprintf(bl_name, sizeof(bl_name), "appledisplay%d",		atomic_inc_return(&count_displays) - 1);	pdata->bd = backlight_device_register(bl_name, NULL, pdata,						&appledisplay_bl_data);	if (IS_ERR(pdata->bd)) {		err("appledisplay: Backlight registration failed");		goto error;	}	pdata->bd->props.max_brightness = 0xff;	/* Try to get brightness */	brightness = appledisplay_bl_get_brightness(pdata->bd);	if (brightness < 0) {		retval = brightness;		err("appledisplay: Error while getting initial brightness: %d", retval);		goto error;	}	/* Set brightness in backlight device */	pdata->bd->props.brightness = brightness;//.........这里部分代码省略.........

static void metrousb_read_int_callback(struct urb *urb){	struct usb_serial_port *port = urb->context;	struct metrousb_private *metro_priv = usb_get_serial_port_data(port);	struct tty_struct *tty;	unsigned char *data = urb->transfer_buffer;	int throttled = 0;	int result = 0;	unsigned long flags = 0;	dev_dbg(&port->dev, "%s/n", __func__);	switch (urb->status) {	case 0:		/* Success status, read from the port. */		break;	case -ECONNRESET:	case -ENOENT:	case -ESHUTDOWN:		/* urb has been terminated. */		dev_dbg(&port->dev,			"%s - urb shutting down, error code=%d/n",			__func__, urb->status);		return;	default:		dev_dbg(&port->dev,			"%s - non-zero urb received, error code=%d/n",			__func__, urb->status);		goto exit;	}	/* Set the data read from the usb port into the serial port buffer. */	tty = tty_port_tty_get(&port->port);	if (tty && urb->actual_length) {		/* Loop through the data copying each byte to the tty layer. */		tty_insert_flip_string(tty, data, urb->actual_length);		/* Force the data to the tty layer. */		tty_flip_buffer_push(tty);	}	tty_kref_put(tty);	/* Set any port variables. */	spin_lock_irqsave(&metro_priv->lock, flags);	throttled = metro_priv->throttled;	spin_unlock_irqrestore(&metro_priv->lock, flags);	/* Continue trying to read if set. */	if (!throttled) {		usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,				 usb_rcvintpipe(port->serial->dev, port->interrupt_in_endpointAddress),				 port->interrupt_in_urb->transfer_buffer,				 port->interrupt_in_urb->transfer_buffer_length,				 metrousb_read_int_callback, port, 1);		result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);		if (result)			dev_err(&port->dev,				"%s - failed submitting interrupt in urb, error code=%d/n",				__func__, result);	}	return;exit:	/* Try to resubmit the urb. */	result = usb_submit_urb(urb, GFP_ATOMIC);	if (result)		dev_err(&port->dev,			"%s - failed submitting interrupt in urb, error code=%d/n",			__func__, result);}

/** *	usb_tranzport_open */static int usb_tranzport_open(struct inode *inode, struct file *file){	struct usb_tranzport *dev;	int subminor;	int retval = 0;	struct usb_interface *interface;	nonseekable_open(inode, file);	subminor = iminor(inode);	mutex_lock(&disconnect_mutex);	interface = usb_find_interface(&usb_tranzport_driver, subminor);	if (!interface) {		err("%s - error, can't find device for minor %d/n",		     __FUNCTION__, subminor);		retval = -ENODEV;		goto unlock_disconnect_exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto unlock_disconnect_exit;	}	/* lock this device */	if (down_interruptible(&dev->sem)) {		retval = -ERESTARTSYS;		goto unlock_disconnect_exit;	}	/* allow opening only once */	if (dev->open_count) {		retval = -EBUSY;		goto unlock_exit;	}	dev->open_count = 1;	/* initialize in direction */	dev->ring_head = 0;	dev->ring_tail = 0;	usb_fill_int_urb(dev->interrupt_in_urb,			 interface_to_usbdev(interface),			 usb_rcvintpipe(interface_to_usbdev(interface),					dev->interrupt_in_endpoint->bEndpointAddress),			 dev->interrupt_in_buffer,			 dev->interrupt_in_endpoint_size,			 usb_tranzport_interrupt_in_callback,			 dev,			 dev->interrupt_in_interval);	dev->interrupt_in_running = 1;	dev->interrupt_in_done = 0;	dev->enable = 1;	dev->offline = 0;	dev->compress_wheel = 1;	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);	if (retval) {		dev_err(&interface->dev, "Couldn't submit interrupt_in_urb %d/n", retval);		dev->interrupt_in_running = 0;		dev->open_count = 0;		goto unlock_exit;	}	/* save device in the file's private structure */	file->private_data = dev;unlock_exit:	up(&dev->sem);unlock_disconnect_exit:	mutex_unlock(&disconnect_mutex);	return retval;}

/** *	iowarrior_probe * *	Called by the usb core when a new device is connected that it thinks *	this driver might be interested in. */static int iowarrior_probe(struct usb_interface *interface,			   const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(interface);	struct iowarrior *dev = NULL;	struct usb_host_interface *iface_desc;	struct usb_endpoint_descriptor *endpoint;	int i;	int retval = -ENOMEM;	/* allocate memory for our device state and initialize it */	dev = kzalloc(sizeof(struct iowarrior), GFP_KERNEL);	if (dev == NULL) {		dev_err(&interface->dev, "Out of memory/n");		return retval;	}	mutex_init(&dev->mutex);	atomic_set(&dev->intr_idx, 0);	atomic_set(&dev->read_idx, 0);	spin_lock_init(&dev->intr_idx_lock);	atomic_set(&dev->overflow_flag, 0);	init_waitqueue_head(&dev->read_wait);	atomic_set(&dev->write_busy, 0);	init_waitqueue_head(&dev->write_wait);	dev->udev = udev;	dev->interface = interface;	iface_desc = interface->cur_altsetting;	dev->product_id = le16_to_cpu(udev->descriptor.idProduct);	/* set up the endpoint information */	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {		endpoint = &iface_desc->endpoint[i].desc;		if (usb_endpoint_is_int_in(endpoint))			dev->int_in_endpoint = endpoint;		if (usb_endpoint_is_int_out(endpoint))			/* this one will match for the IOWarrior56 only */			dev->int_out_endpoint = endpoint;	}	/* we have to check the report_size often, so remember it in the endianess suitable for our machine */	dev->report_size = usb_endpoint_maxp(dev->int_in_endpoint);	if ((dev->interface->cur_altsetting->desc.bInterfaceNumber == 0) &&	    (dev->product_id == USB_DEVICE_ID_CODEMERCS_IOW56))		/* IOWarrior56 has wMaxPacketSize different from report size */		dev->report_size = 7;	/* create the urb and buffer for reading */	dev->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->int_in_urb) {		dev_err(&interface->dev, "Couldn't allocate interrupt_in_urb/n");		goto error;	}	dev->int_in_buffer = kmalloc(dev->report_size, GFP_KERNEL);	if (!dev->int_in_buffer) {		dev_err(&interface->dev, "Couldn't allocate int_in_buffer/n");		goto error;	}	usb_fill_int_urb(dev->int_in_urb, dev->udev,			 usb_rcvintpipe(dev->udev,					dev->int_in_endpoint->bEndpointAddress),			 dev->int_in_buffer, dev->report_size,			 iowarrior_callback, dev,			 dev->int_in_endpoint->bInterval);	/* create an internal buffer for interrupt data from the device */	dev->read_queue =	    kmalloc(((dev->report_size + 1) * MAX_INTERRUPT_BUFFER),		    GFP_KERNEL);	if (!dev->read_queue) {		dev_err(&interface->dev, "Couldn't allocate read_queue/n");		goto error;	}	/* Get the serial-number of the chip */	memset(dev->chip_serial, 0x00, sizeof(dev->chip_serial));	usb_string(udev, udev->descriptor.iSerialNumber, dev->chip_serial,		   sizeof(dev->chip_serial));	if (strlen(dev->chip_serial) != 8)		memset(dev->chip_serial, 0x00, sizeof(dev->chip_serial));	/* Set the idle timeout to 0, if this is interface 0 */	if (dev->interface->cur_altsetting->desc.bInterfaceNumber == 0) {	    usb_control_msg(udev, usb_sndctrlpipe(udev, 0),			    0x0A,			    USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0,			    0, NULL, 0, USB_CTRL_SET_TIMEOUT);	}	/* allow device read and ioctl */	dev->present = 1;	/* we can register the device now, as it is ready */	usb_set_intfdata(interface, dev);//.........这里部分代码省略.........

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) {		err("bcm5974: out of memory");		goto err_free_devs;	}	dev->udev = udev;	dev->intf = iface;	dev->input = input_dev;	dev->cfg = *cfg;	mutex_init(&dev->pm_mutex);	/* setup urbs */	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;	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;	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:	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);err_free_devs:	usb_set_intfdata(iface, NULL);	input_free_device(input_dev);	kfree(dev);	return error;}

int st5481_setup_usb(struct st5481_adapter *adapter){	struct usb_device *dev = adapter->usb_dev;	struct st5481_ctrl *ctrl = &adapter->ctrl;	struct st5481_intr *intr = &adapter->intr;	struct usb_interface *intf;	struct usb_host_interface *altsetting = NULL;	struct usb_host_endpoint *endpoint;	int status;	struct urb *urb;	u8 *buf;		DBG(2,"");		if ((status = usb_reset_configuration (dev)) < 0) {		WARNING("reset_configuration failed,status=%d",status);		return status;	}	intf = usb_ifnum_to_if(dev, 0);	if (intf)		altsetting = usb_altnum_to_altsetting(intf, 3);	if (!altsetting)		return -ENXIO;	// Check if the config is sane	if ( altsetting->desc.bNumEndpoints != 7 ) {		WARNING("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);		return -EINVAL;	}	// The descriptor is wrong for some early samples of the ST5481 chip	altsetting->endpoint[3].desc.wMaxPacketSize = __constant_cpu_to_le16(32);	altsetting->endpoint[4].desc.wMaxPacketSize = __constant_cpu_to_le16(32);	// Use alternative setting 3 on interface 0 to have 2B+D	if ((status = usb_set_interface (dev, 0, 3)) < 0) {		WARNING("usb_set_interface failed,status=%d",status);		return status;	}	// Allocate URB for control endpoint	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		return -ENOMEM;	}	ctrl->urb = urb;		// Fill the control URB	usb_fill_control_urb (urb, dev, 			  usb_sndctrlpipe(dev, 0),			  NULL, NULL, 0, usb_ctrl_complete, adapter);			fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));	// Allocate URBs and buffers for interrupt endpoint	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) { 		return -ENOMEM;	}	intr->urb = urb;		buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);	if (!buf) {		return -ENOMEM;	}	endpoint = &altsetting->endpoint[EP_INT-1];					// Fill the interrupt URB	usb_fill_int_urb(urb, dev,		     usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),		     buf, INT_PKT_SIZE,		     usb_int_complete, adapter,		     endpoint->desc.bInterval);			return 0;}

static int bpa10x_open(struct hci_dev *hdev){	struct bpa10x_data *data = hdev->driver_data;	struct usb_device *udev = data->udev;	unsigned long flags;	int err;	BT_DBG("hdev %p data %p", hdev, data);	if (test_and_set_bit(HCI_RUNNING, &hdev->flags))		return 0;	data->cmd_urb = bpa10x_alloc_urb(udev, usb_sndctrlpipe(udev, BPA10X_CMD_EP),					BPA10X_CMD_BUF_SIZE, GFP_KERNEL, data);	if (!data->cmd_urb) {		err = -ENOMEM;		goto done;	}	data->evt_urb = bpa10x_alloc_urb(udev, usb_rcvintpipe(udev, BPA10X_EVT_EP),					BPA10X_EVT_BUF_SIZE, GFP_KERNEL, data);	if (!data->evt_urb) {		bpa10x_free_urb(data->cmd_urb);		err = -ENOMEM;		goto done;	}	data->rx_urb = bpa10x_alloc_urb(udev, usb_rcvbulkpipe(udev, BPA10X_RX_EP),					BPA10X_RX_BUF_SIZE, GFP_KERNEL, data);	if (!data->rx_urb) {		bpa10x_free_urb(data->evt_urb);		bpa10x_free_urb(data->cmd_urb);		err = -ENOMEM;		goto done;	}	data->tx_urb = bpa10x_alloc_urb(udev, usb_sndbulkpipe(udev, BPA10X_TX_EP),					BPA10X_TX_BUF_SIZE, GFP_KERNEL, data);	if (!data->rx_urb) {		bpa10x_free_urb(data->rx_urb);		bpa10x_free_urb(data->evt_urb);		bpa10x_free_urb(data->cmd_urb);		err = -ENOMEM;		goto done;	}	write_lock_irqsave(&data->lock, flags);	err = usb_submit_urb(data->evt_urb, GFP_ATOMIC);	if (err < 0) {		BT_ERR("%s submit failed for event urb %p with error %d",					data->hdev->name, data->evt_urb, err);	} else {		err = usb_submit_urb(data->rx_urb, GFP_ATOMIC);		if (err < 0) {			BT_ERR("%s submit failed for rx urb %p with error %d",					data->hdev->name, data->evt_urb, err);			usb_kill_urb(data->evt_urb);		}	}	write_unlock_irqrestore(&data->lock, flags);done:	if (err < 0)		clear_bit(HCI_RUNNING, &hdev->flags);	return err;}

int st5481_setup_usb(struct st5481_adapter *adapter){	struct usb_device *dev = adapter->usb_dev;	struct st5481_ctrl *ctrl = &adapter->ctrl;	struct st5481_intr *intr = &adapter->intr;	struct usb_interface *intf;	struct usb_host_interface *altsetting = NULL;	struct usb_host_endpoint *endpoint;	int status;	struct urb *urb;	u8 *buf;	DBG(2, "");	if ((status = usb_reset_configuration(dev)) < 0) {		WARNING("reset_configuration failed,status=%d", status);		return status;	}	intf = usb_ifnum_to_if(dev, 0);	if (intf)		altsetting = usb_altnum_to_altsetting(intf, 3);	if (!altsetting)		return -ENXIO;		if (altsetting->desc.bNumEndpoints != 7) {		WARNING("expecting 7 got %d endpoints!", altsetting->desc.bNumEndpoints);		return -EINVAL;	}		altsetting->endpoint[3].desc.wMaxPacketSize = __constant_cpu_to_le16(32);	altsetting->endpoint[4].desc.wMaxPacketSize = __constant_cpu_to_le16(32);		if ((status = usb_set_interface(dev, 0, 3)) < 0) {		WARNING("usb_set_interface failed,status=%d", status);		return status;	}		urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		return -ENOMEM;	}	ctrl->urb = urb;		usb_fill_control_urb(urb, dev,			     usb_sndctrlpipe(dev, 0),			     NULL, NULL, 0, usb_ctrl_complete, adapter);	fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));		urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		return -ENOMEM;	}	intr->urb = urb;	buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);	if (!buf) {		return -ENOMEM;	}	endpoint = &altsetting->endpoint[EP_INT-1];		usb_fill_int_urb(urb, dev,			 usb_rcvintpipe(dev, endpoint->desc.bEndpointAddress),			 buf, INT_PKT_SIZE,			 usb_int_complete, adapter,			 endpoint->desc.bInterval);	return 0;}

static void bcm203x_complete(struct urb *urb){    struct bcm203x_data *data = urb->context;    struct usb_device *udev = urb->dev;    int len;    BT_DBG("udev %p urb %p", udev, urb);    if (urb->status) {        BT_ERR("URB failed with status %d", urb->status);        data->state = BCM203X_ERROR;        return;    }    switch (data->state) {    case BCM203X_LOAD_MINIDRV:        memcpy(data->buffer, "#", 1);        usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, BCM203X_OUT_EP),                data->buffer, 1, bcm203x_complete, data);        data->state = BCM203X_SELECT_MEMORY;        schedule_work(&data->work);        break;    case BCM203X_SELECT_MEMORY:        usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, BCM203X_IN_EP),                data->buffer, 32, bcm203x_complete, data, 1);        data->state = BCM203X_CHECK_MEMORY;        if (usb_submit_urb(data->urb, GFP_ATOMIC) < 0)            BT_ERR("Can't submit URB");        break;    case BCM203X_CHECK_MEMORY:        if (data->buffer[0] != '#') {            BT_ERR("Memory select failed");            data->state = BCM203X_ERROR;            break;        }        data->state = BCM203X_LOAD_FIRMWARE;    case BCM203X_LOAD_FIRMWARE:        if (data->fw_sent == data->fw_size) {            usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, BCM203X_IN_EP),                data->buffer, 32, bcm203x_complete, data, 1);            data->state = BCM203X_CHECK_FIRMWARE;        } else {            len = min_t(uint, data->fw_size - data->fw_sent, 4096);            usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, BCM203X_OUT_EP),                data->fw_data + data->fw_sent, len, bcm203x_complete, data);            data->fw_sent += len;        }        if (usb_submit_urb(data->urb, GFP_ATOMIC) < 0)            BT_ERR("Can't submit URB");        break;    case BCM203X_CHECK_FIRMWARE:        if (data->buffer[0] != '.') {            BT_ERR("Firmware loading failed");            data->state = BCM203X_ERROR;            break;        }        data->state = BCM203X_RESET;        break;    }}

static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev(intf);	struct usb_xpad *xpad;	struct usb_endpoint_descriptor *ep_irq_in;	int ep_irq_in_idx;	int i, error;	for (i = 0; xpad_device[i].idVendor; i++) {		if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&		    (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))			break;	}	if (xpad_device[i].xtype == XTYPE_XBOXONE &&	    intf->cur_altsetting->desc.bInterfaceNumber != 0) {		/*		 * The Xbox One controller lists three interfaces all with the		 * same interface class, subclass and protocol. Differentiate by		 * interface number.		 */		return -ENODEV;	}	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);	if (!xpad)		return -ENOMEM;	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));	xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN,					 GFP_KERNEL, &xpad->idata_dma);	if (!xpad->idata) {		error = -ENOMEM;		goto err_free_mem;	}	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);	if (!xpad->irq_in) {		error = -ENOMEM;		goto err_free_idata;	}	xpad->udev = udev;	xpad->intf = intf;	xpad->mapping = xpad_device[i].mapping;	xpad->xtype = xpad_device[i].xtype;	xpad->name = xpad_device[i].name;	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 err_free_in_urb;	/* 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);	error = xpad_init_input(xpad);	if (error)		goto err_deinit_output;	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)//.........这里部分代码省略.........

int __devinit st5481_setup_usb(struct st5481_adapter *adapter){	struct usb_device *dev = adapter->usb_dev;	struct st5481_ctrl *ctrl = &adapter->ctrl;	struct st5481_intr *intr = &adapter->intr;	struct usb_interface_descriptor *altsetting;	struct usb_endpoint_descriptor *endpoint;	int status;	urb_t *urb;	u_char *buf;		DBG(1,"");		if ((status = usb_set_configuration (dev,dev->config[0].bConfigurationValue)) < 0) {		WARN("set_configuration failed,status=%d",status);		return status;	}		altsetting = &(dev->config->interface[0].altsetting[3]);		// Check if the config is sane	if ( altsetting->bNumEndpoints != 7 ) {		WARN("expecting 7 got %d endpoints!", altsetting->bNumEndpoints);		return -EINVAL;	}	// The descriptor is wrong for some early samples of the ST5481 chip	altsetting->endpoint[3].wMaxPacketSize = 32;	altsetting->endpoint[4].wMaxPacketSize = 32;	// Use alternative setting 3 on interface 0 to have 2B+D	if ((status = usb_set_interface (dev, 0, 3)) < 0) {		WARN("usb_set_interface failed,status=%d",status);		return status;	}	// Allocate URB for control endpoint	urb = usb_alloc_urb(0);	if (!urb) {		return -ENOMEM;	}	ctrl->urb = urb;		// Fill the control URB	FILL_CONTROL_URB (urb, dev, 			  usb_sndctrlpipe(dev, 0),			  NULL, NULL, 0, usb_ctrl_complete, adapter);			fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));	// Allocate URBs and buffers for interrupt endpoint	urb = usb_alloc_urb(0);	if (!urb) { 		return -ENOMEM;	}	intr->urb = urb;		buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);	if (!buf) {		return -ENOMEM;	}	endpoint = &altsetting->endpoint[EP_INT-1];					// Fill the interrupt URB	FILL_INT_URB(urb, dev,		     usb_rcvintpipe(dev, endpoint->bEndpointAddress),		     buf, INT_PKT_SIZE,		     usb_int_complete, adapter,		     endpoint->bInterval);			return 0;}

int rmnet_usb_ctrl_probe(struct usb_interface *intf,		struct usb_host_endpoint *int_in, struct rmnet_ctrl_dev *dev){	u16				wMaxPacketSize;	struct usb_endpoint_descriptor	*ep;	struct usb_device		*udev;	int				interval;	int				ret = 0;	udev = interface_to_usbdev(intf);	if (!dev) {		pr_err("%s: Ctrl device not found/n", __func__);		return -ENODEV;	}	dev->int_pipe = usb_rcvintpipe(udev,		int_in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);	mutex_lock(&dev->dev_lock);	dev->intf = intf;	/*TBD: for now just update CD status*/	dev->cbits_tolocal = ACM_CTRL_CD;	/*send DTR high to modem*/	dev->cbits_tomdm = ACM_CTRL_DTR;	mutex_unlock(&dev->dev_lock);	dev->resp_available = false;	dev->snd_encap_cmd_cnt = 0;	dev->get_encap_resp_cnt = 0;	dev->resp_avail_cnt = 0;	dev->tx_ctrl_err_cnt = 0;	dev->set_ctrl_line_state_cnt = 0;	ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),			USB_CDC_REQ_SET_CONTROL_LINE_STATE,			(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE),			dev->cbits_tomdm,			dev->intf->cur_altsetting->desc.bInterfaceNumber,			NULL, 0, USB_CTRL_SET_TIMEOUT);	if (ret < 0)		return ret;	dev->set_ctrl_line_state_cnt++;	dev->inturb = usb_alloc_urb(0, GFP_KERNEL);	if (!dev->inturb) {		dev_err(dev->devicep, "Error allocating int urb/n");		return -ENOMEM;	}	/*use max pkt size from ep desc*/	ep = &dev->intf->cur_altsetting->endpoint[0].desc;	wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);	dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);	if (!dev->intbuf) {		usb_free_urb(dev->inturb);		dev_err(dev->devicep, "Error allocating int buffer/n");		return -ENOMEM;	}	dev->in_ctlreq->bRequestType =		(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);	dev->in_ctlreq->bRequest  = USB_CDC_GET_ENCAPSULATED_RESPONSE;	dev->in_ctlreq->wValue = 0;	dev->in_ctlreq->wIndex =		dev->intf->cur_altsetting->desc.bInterfaceNumber;	dev->in_ctlreq->wLength = cpu_to_le16(DEFAULT_READ_URB_LENGTH);	interval = max((int)int_in->desc.bInterval,			(udev->speed == USB_SPEED_HIGH) ? HS_INTERVAL							: FS_LS_INTERVAL);	usb_fill_int_urb(dev->inturb, udev,			 dev->int_pipe,			 dev->intbuf, wMaxPacketSize,			 notification_available_cb, dev, interval);	usb_mark_last_busy(udev);	ret = rmnet_usb_ctrl_start_rx(dev);	if (!ret)		dev->is_connected = true;	ctl_msg_dbg_mask = 0;	return ret;}

/* * RPC done RNDIS-style.  Caller guarantees: * - message is properly byteswapped * - there's no other request pending * - buf can hold up to 1KB response (required by RNDIS spec) * On return, the first few entries are already byteswapped. * * Call context is likely probe(), before interface name is known, * which is why we won't try to use it in the diagnostics. */int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen){	struct cdc_state	*info = (void *) &dev->data;	struct usb_cdc_notification notification;	int			master_ifnum;	int			retval;	int			partial;	unsigned		count;	u32			xid = 0, msg_len, request_id, msg_type, rsp,				status;	/* REVISIT when this gets called from contexts other than probe() or	 * disconnect(): either serialize, or dispatch responses on xid	 */	msg_type = le32_to_cpu(buf->msg_type);	/* Issue the request; xid is unique, don't bother byteswapping it */	if (likely(msg_type != RNDIS_MSG_HALT && msg_type != RNDIS_MSG_RESET)) {		xid = dev->xid++;		if (!xid)			xid = dev->xid++;		buf->request_id = (__force __le32) xid;	}	master_ifnum = info->control->cur_altsetting->desc.bInterfaceNumber;	retval = usb_control_msg(dev->udev,		usb_sndctrlpipe(dev->udev, 0),		USB_CDC_SEND_ENCAPSULATED_COMMAND,		USB_TYPE_CLASS | USB_RECIP_INTERFACE,		0, master_ifnum,		buf, le32_to_cpu(buf->msg_len),		RNDIS_CONTROL_TIMEOUT_MS);	if (unlikely(retval < 0 || xid == 0))		return retval;	/* Some devices don't respond on the control channel until	 * polled on the status channel, so do that first. */	if (dev->driver_info->data & RNDIS_DRIVER_DATA_POLL_STATUS) {		retval = usb_interrupt_msg(			dev->udev,			usb_rcvintpipe(dev->udev,				       dev->status->desc.bEndpointAddress),			&notification, sizeof(notification), &partial,			RNDIS_CONTROL_TIMEOUT_MS);		if (unlikely(retval < 0))			return retval;	}	/* Poll the control channel; the request probably completed immediately */	rsp = le32_to_cpu(buf->msg_type) | RNDIS_MSG_COMPLETION;	for (count = 0; count < 10; count++) {		memset(buf, 0, CONTROL_BUFFER_SIZE);		retval = usb_control_msg(dev->udev,			usb_rcvctrlpipe(dev->udev, 0),			USB_CDC_GET_ENCAPSULATED_RESPONSE,			USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,			0, master_ifnum,			buf, buflen,			RNDIS_CONTROL_TIMEOUT_MS);		if (likely(retval >= 8)) {			msg_type = le32_to_cpu(buf->msg_type);			msg_len = le32_to_cpu(buf->msg_len);			status = le32_to_cpu(buf->status);			request_id = (__force u32) buf->request_id;			if (likely(msg_type == rsp)) {				if (likely(request_id == xid)) {					if (unlikely(rsp == RNDIS_MSG_RESET_C))						return 0;					if (likely(RNDIS_STATUS_SUCCESS ==							status))						return 0;					dev_dbg(&info->control->dev,						"rndis reply status %08x/n",						status);					return -EL3RST;				}				dev_dbg(&info->control->dev,					"rndis reply id %d expected %d/n",					request_id, xid);				/* then likely retry */			} else switch (msg_type) {			case RNDIS_MSG_INDICATE: /* fault/event */				rndis_msg_indicate(dev, (void *)buf, buflen);				break;			case RNDIS_MSG_KEEPALIVE: { /* ping */				struct rndis_keepalive_c *msg = (void *)buf;				msg->msg_type = cpu_to_le32(RNDIS_MSG_KEEPALIVE_C);				msg->msg_len = cpu_to_le32(sizeof *msg);				msg->status = cpu_to_le32(RNDIS_STATUS_SUCCESS);//.........这里部分代码省略.........

//.........这里部分代码省略.........	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 fail3;	error = xpad_init_ff(xpad);	if (error)		goto fail4;	error = xpad_led_probe(xpad);	if (error)		goto fail5;	/* 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;	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;

static int gigaset_probe(struct usb_interface *interface,             const struct usb_device_id *id){    int retval;    struct usb_device *udev = interface_to_usbdev(interface);    struct usb_host_interface *hostif = interface->cur_altsetting;    struct cardstate *cs = NULL;    struct usb_cardstate *ucs = NULL;    struct usb_endpoint_descriptor *endpoint;    int buffer_size;    gig_dbg(DEBUG_ANY, "%s: Check if device matches ...", __func__);    /* See if the device offered us matches what we can accept */    if ((le16_to_cpu(udev->descriptor.idVendor)  != USB_M105_VENDOR_ID) ||        (le16_to_cpu(udev->descriptor.idProduct) != USB_M105_PRODUCT_ID)) {        gig_dbg(DEBUG_ANY, "device ID (0x%x, 0x%x) not for me - skip",            le16_to_cpu(udev->descriptor.idVendor),            le16_to_cpu(udev->descriptor.idProduct));        return -ENODEV;    }    if (hostif->desc.bInterfaceNumber != 0) {        gig_dbg(DEBUG_ANY, "interface %d not for me - skip",            hostif->desc.bInterfaceNumber);        return -ENODEV;    }    if (hostif->desc.bAlternateSetting != 0) {        dev_notice(&udev->dev, "unsupported altsetting %d - skip",               hostif->desc.bAlternateSetting);        return -ENODEV;    }    if (hostif->desc.bInterfaceClass != 255) {        dev_notice(&udev->dev, "unsupported interface class %d - skip",               hostif->desc.bInterfaceClass);        return -ENODEV;    }    dev_info(&udev->dev, "%s: Device matched ... !/n", __func__);    /* allocate memory for our device state and intialize it */    cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);    if (!cs)        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, GFP_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;    ucs->busy = 0;    ucs->read_urb = usb_alloc_urb(0, GFP_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);//.........这里部分代码省略.........

static int xpad_probe(struct usb_interface *intf, const struct usb_device_id *id){	struct usb_device *udev = interface_to_usbdev (intf);	struct usb_xpad *xpad;	struct input_dev *input_dev;	struct usb_endpoint_descriptor *ep_irq_in;	int i;	int error = -ENOMEM;	for (i = 0; xpad_device[i].idVendor; i++) {		if ((le16_to_cpu(udev->descriptor.idVendor) == xpad_device[i].idVendor) &&		    (le16_to_cpu(udev->descriptor.idProduct) == xpad_device[i].idProduct))			break;	}	xpad = kzalloc(sizeof(struct usb_xpad), GFP_KERNEL);	input_dev = input_allocate_device();	if (!xpad || !input_dev)		goto fail1;	xpad->idata = usb_buffer_alloc(udev, XPAD_PKT_LEN,				       GFP_ATOMIC, &xpad->idata_dma);	if (!xpad->idata)		goto fail1;	xpad->irq_in = usb_alloc_urb(0, GFP_KERNEL);	if (!xpad->irq_in)		goto fail2;	xpad->udev = udev;	xpad->dpad_mapping = xpad_device[i].dpad_mapping;	if (xpad->dpad_mapping == MAP_DPAD_UNKNOWN)		xpad->dpad_mapping = dpad_to_buttons;	xpad->dev = input_dev;	usb_make_path(udev, xpad->phys, sizeof(xpad->phys));	strlcat(xpad->phys, "/input0", sizeof(xpad->phys));	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(EV_KEY) | BIT(EV_ABS);	/* set up buttons */	for (i = 0; xpad_btn[i] >= 0; i++)		set_bit(xpad_btn[i], input_dev->keybit);	if (xpad->dpad_mapping == MAP_DPAD_TO_BUTTONS)		for (i = 0; xpad_btn_pad[i] >= 0; i++)			set_bit(xpad_btn_pad[i], input_dev->keybit);	/* set up axes */	for (i = 0; xpad_abs[i] >= 0; i++)		xpad_set_up_abs(input_dev, xpad_abs[i]);	if (xpad->dpad_mapping == MAP_DPAD_TO_AXES)		for (i = 0; xpad_abs_pad[i] >= 0; i++)		    xpad_set_up_abs(input_dev, xpad_abs_pad[i]);	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 fail3;	usb_set_intfdata(intf, xpad);	return 0; fail3:	usb_free_urb(xpad->irq_in); fail2:	usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); fail1:	input_free_device(input_dev);	kfree(xpad);	return error;}

/* * 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) {		err("kingsun-sir: expected 2 endpoints, found %d",		    interface->desc.bNumEndpoints);		return -ENODEV;	}	endpoint = &interface->endpoint[KINGSUN_EP_IN].desc;	if (!usb_endpoint_is_int_in(endpoint)) {		err("kingsun-sir: endpoint 0 is not interrupt IN");		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) {		err("%s: endpoint 0 has max packet size %d not in range",		    __FILE__, maxp_in);		return -ENODEV;	}	endpoint = &interface->endpoint[KINGSUN_EP_OUT].desc;	if (!usb_endpoint_is_int_out(endpoint)) {		err("kingsun-sir: endpoint 1 is not interrupt OUT");		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_MODULE_OWNER(net);	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 = (__u8 *)kmalloc(kingsun->max_rx, GFP_KERNEL);	if (!kingsun->in_buf)		goto free_mem;	/* Allocate output buffer */	kingsun->out_buf = (__u8 *)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. */	kingsun->qos.baud_rate.bits       &= IR_9600;	kingsun->qos.min_turn_time.bits   &= KINGSUN_MTT;	irda_qos_bits_to_value(&kingsun->qos);//.........这里部分代码省略.........

//.........这里部分代码省略.........	data->iin_bTag = 2;	/* USBTMC devices have only one setting, so use that */	iface_desc = data->intf->cur_altsetting;	data->ifnum = iface_desc->desc.bInterfaceNumber;	/* Find bulk in endpoint */	for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) {		endpoint = &iface_desc->endpoint[n].desc;		if (usb_endpoint_is_bulk_in(endpoint)) {			data->bulk_in = endpoint->bEndpointAddress;			dev_dbg(&intf->dev, "Found bulk in endpoint at %u/n",				data->bulk_in);			break;		}	}	/* Find bulk out endpoint */	for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) {		endpoint = &iface_desc->endpoint[n].desc;		if (usb_endpoint_is_bulk_out(endpoint)) {			data->bulk_out = endpoint->bEndpointAddress;			dev_dbg(&intf->dev, "Found Bulk out endpoint at %u/n",				data->bulk_out);			break;		}	}	/* Find int endpoint */	for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) {		endpoint = &iface_desc->endpoint[n].desc;		if (usb_endpoint_is_int_in(endpoint)) {			data->iin_ep_present = 1;			data->iin_ep = endpoint->bEndpointAddress;			data->iin_wMaxPacketSize = usb_endpoint_maxp(endpoint);			data->iin_interval = endpoint->bInterval;			dev_dbg(&intf->dev, "Found Int in endpoint at %u/n",				data->iin_ep);			break;		}	}	retcode = get_capabilities(data);	if (retcode)		dev_err(&intf->dev, "can't read capabilities/n");	else		retcode = sysfs_create_group(&intf->dev.kobj,					     &capability_attr_grp);	if (data->iin_ep_present) {		/* allocate int urb */		data->iin_urb = usb_alloc_urb(0, GFP_KERNEL);		if (!data->iin_urb)			goto error_register;		/* will reference data in int urb */		kref_get(&data->kref);		/* allocate buffer for interrupt in */		data->iin_buffer = kmalloc(data->iin_wMaxPacketSize,					GFP_KERNEL);		if (!data->iin_buffer)			goto error_register;		/* fill interrupt urb */		usb_fill_int_urb(data->iin_urb, data->usb_dev,				usb_rcvintpipe(data->usb_dev, data->iin_ep),				data->iin_buffer, data->iin_wMaxPacketSize,				usbtmc_interrupt,				data, data->iin_interval);		retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);		if (retcode) {			dev_err(&intf->dev, "Failed to submit iin_urb/n");			goto error_register;		}	}	retcode = sysfs_create_group(&intf->dev.kobj, &data_attr_grp);	retcode = usb_register_dev(intf, &usbtmc_class);	if (retcode) {		dev_err(&intf->dev, "Not able to get a minor"			" (base %u, slice default): %d/n", USBTMC_MINOR_BASE,			retcode);		goto error_register;	}	dev_dbg(&intf->dev, "Using minor number %d/n", intf->minor);	return 0;error_register:	sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);	sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);	usbtmc_free_int(data);	kref_put(&data->kref, usbtmc_delete);	return retcode;}