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

static int smdhsic_probe(struct usb_interface *intf,			 const struct usb_device_id *id){	int devid = -1;	int err;	const struct usb_cdc_union_desc *union_header = NULL;	const struct usb_host_interface *data_desc;	struct usb_interface *data_intf;	struct usb_device *usbdev;	struct str_intf_priv *intfpriv = NULL;	struct usb_driver *driver;	struct str_smdipc *smdipc;	struct str_hsic *hsic;	u8 *data;	int len;	pr_info("%s: Enter/n", __func__);	usbdev = interface_to_usbdev(intf);	g_usbdev.usbdev = usbdev;	driver = get_usb_driver(intf);	data = intf->altsetting->extra;	len = intf->altsetting->extralen;	if (!len) {		if (intf->cur_altsetting->endpoint->extralen &&		    intf->cur_altsetting->endpoint->extra) {			pr_debug(			       "%s: Seeking extra descriptors on endpoint/n",			       __func__);			len = intf->cur_altsetting->endpoint->extralen;			data = intf->cur_altsetting->endpoint->extra;		} else {			pr_err(			       "%s: Zero length descriptor reference/n",			       __func__);			return -EINVAL;		}	}	if (!len) {		pr_err("%s: Zero length descriptor reference/n",		       __func__);		return -EINVAL;	}	while (len > 0) {		if (data[1] == USB_DT_CS_INTERFACE) {			switch (data[2]) {			case USB_CDC_UNION_TYPE:				if (union_header)					break;				union_header =				    (struct usb_cdc_union_desc *)data;				break;			default:				break;			}		}		data += data[0];		len -= data[0];	}	if (!union_header) {		pr_err("%s:USB CDC is not union type/n", __func__);		return -EINVAL;	}	data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);	if (!data_intf) {		pr_err("%s:data_inferface is NULL/n", __func__);		return -ENODEV;	}	data_desc = data_intf->altsetting;	if (!data_desc) {		pr_err("%s:data_desc is NULL/n", __func__);		return -ENODEV;	}	switch (id->driver_info) {	case XMM6260_PSI_DOWN:		pr_warn("%s:XMM6260_PSI_DOWN/n", __func__);		intfpriv = smd_create_dev(data_intf, usbdev,					data_desc, DOWN_DEV_ID);		break;	case XMM6260_BIN_DOWN:		intfpriv = smd_create_dev(data_intf, usbdev,					data_desc, DOWN_DEV_ID);		break;	case XMM6260_CHANNEL:		devid = intf->altsetting->desc.bInterfaceNumber / 2;		intfpriv = smd_create_dev(data_intf, usbdev, data_desc, devid);		break;	default:		pr_err("%s: Undefined driver_info: %lu/n",			__func__, id->driver_info);		break;	}//.........这里部分代码省略.........

//.........这里部分代码省略.........    data = kzalloc(sizeof(*data), GFP_KERNEL);    if (!data)        return -ENOMEM;    for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {        ep_desc = &intf->cur_altsetting->endpoint[i].desc;        if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {            data->intr_ep = ep_desc;            continue;        }        if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {            data->bulk_tx_ep = ep_desc;            continue;        }        if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {            data->bulk_rx_ep = ep_desc;            continue;        }    }    if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {        kfree(data);        return -ENODEV;    }    data->cmdreq_type = USB_TYPE_CLASS;    data->udev = interface_to_usbdev(intf);    data->intf = intf;    spin_lock_init(&data->lock);    INIT_WORK(&data->work, btusb_work);    INIT_WORK(&data->waker, btusb_waker);    spin_lock_init(&data->txlock);    init_usb_anchor(&data->tx_anchor);    init_usb_anchor(&data->intr_anchor);    init_usb_anchor(&data->bulk_anchor);    init_usb_anchor(&data->isoc_anchor);    init_usb_anchor(&data->deferred);    hdev = hci_alloc_dev();    if (!hdev) {        kfree(data);        return -ENOMEM;    }    HDEV_BUS = HCI_USB;    data->hdev = hdev;    SET_HCIDEV_DEV(hdev, &intf->dev);    hdev->open     = btusb_open;    hdev->close    = btusb_close;    hdev->flush    = btusb_flush;    hdev->send     = btusb_send_frame;    hdev->notify   = btusb_notify;#if LINUX_VERSION_CODE > KERNEL_VERSION(3, 4, 0)    hci_set_drvdata(hdev, data);#else    hdev->driver_data = data;    hdev->destruct = btusb_destruct;    hdev->owner = THIS_MODULE;#endif    /* Interface numbers are hardcoded in the specification */    data->isoc = usb_ifnum_to_if(data->udev, 1);    if (data->isoc) {        err = usb_driver_claim_interface(&btusb_driver,                                         data->isoc, data);        if (err < 0) {            hci_free_dev(hdev);            kfree(data);            return err;        }    }    err = hci_register_dev(hdev);    if (err < 0) {        hci_free_dev(hdev);        kfree(data);        return err;    }    usb_set_intfdata(intf, data);    return 0;}

static int acm_probe(struct usb_interface *intf,		     const struct usb_device_id *id){	struct usb_cdc_union_desc *union_header = NULL;	struct usb_cdc_country_functional_desc *cfd = NULL;	unsigned char *buffer = intf->altsetting->extra;	int buflen = intf->altsetting->extralen;	struct usb_interface *control_interface;	struct usb_interface *data_interface;	struct usb_endpoint_descriptor *epctrl = NULL;	struct usb_endpoint_descriptor *epread = NULL;	struct usb_endpoint_descriptor *epwrite = NULL;	struct usb_device *usb_dev = interface_to_usbdev(intf);	struct acm *acm;	int minor;	int ctrlsize, readsize;	u8 *buf;	u8 ac_management_function = 0;	u8 call_management_function = 0;	int call_interface_num = -1;	int data_interface_num = -1;	unsigned long quirks;	int num_rx_buf;	int i;	int combined_interfaces = 0;	struct device *tty_dev;	int rv = -ENOMEM;	/* normal quirks */	quirks = (unsigned long)id->driver_info;	if (quirks == IGNORE_DEVICE)		return -ENODEV;	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;	/* handle quirks deadly to normal probing*/	if (quirks == NO_UNION_NORMAL) {		data_interface = usb_ifnum_to_if(usb_dev, 1);		control_interface = usb_ifnum_to_if(usb_dev, 0);		goto skip_normal_probe;	}	/* normal probing*/	if (!buffer) {		dev_err(&intf->dev, "Weird descriptor references/n");		return -EINVAL;	}	if (!buflen) {		if (intf->cur_altsetting->endpoint &&				intf->cur_altsetting->endpoint->extralen &&				intf->cur_altsetting->endpoint->extra) {			dev_dbg(&intf->dev,				"Seeking extra descriptors on endpoint/n");			buflen = intf->cur_altsetting->endpoint->extralen;			buffer = intf->cur_altsetting->endpoint->extra;		} else {			dev_err(&intf->dev,				"Zero length descriptor references/n");			return -EINVAL;		}	}	while (buflen > 0) {		if (buffer[1] != USB_DT_CS_INTERFACE) {			dev_err(&intf->dev, "skipping garbage/n");			goto next_desc;		}		switch (buffer[2]) {		case USB_CDC_UNION_TYPE: /* we've found it */			if (union_header) {				dev_err(&intf->dev, "More than one "					"union descriptor, skipping .../n");				goto next_desc;			}			union_header = (struct usb_cdc_union_desc *)buffer;			break;		case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/			cfd = (struct usb_cdc_country_functional_desc *)buffer;			break;		case USB_CDC_HEADER_TYPE: /* maybe check version */			break; /* for now we ignore it */		case USB_CDC_ACM_TYPE:			ac_management_function = buffer[3];			break;		case USB_CDC_CALL_MANAGEMENT_TYPE:			call_management_function = buffer[3];			call_interface_num = buffer[4];			if ((quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)				dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem./n");			break;		default:			/* there are LOTS more CDC descriptors that			 * could legitimately be found here.			 */			dev_dbg(&intf->dev, "Ignoring descriptor: "					"type %02x, length %d/n",					buffer[2], buffer[0]);//.........这里部分代码省略.........

static int acm_probe (struct usb_interface *intf,		      const struct usb_device_id *id){	struct usb_cdc_union_desc *union_header = NULL;	struct usb_cdc_country_functional_desc *cfd = NULL;	unsigned char *buffer = intf->altsetting->extra;	int buflen = intf->altsetting->extralen;	struct usb_interface *control_interface;	struct usb_interface *data_interface;	struct usb_endpoint_descriptor *epctrl;	struct usb_endpoint_descriptor *epread;	struct usb_endpoint_descriptor *epwrite;	struct usb_device *usb_dev = interface_to_usbdev(intf);	struct acm *acm;	int minor;	int ctrlsize,readsize;	u8 *buf;	u8 ac_management_function = 0;	u8 call_management_function = 0;	int call_interface_num = -1;	int data_interface_num;	unsigned long quirks;	int num_rx_buf;	int i;	/* normal quirks */	quirks = (unsigned long)id->driver_info;	num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;	/* handle quirks deadly to normal probing*/	if (quirks == NO_UNION_NORMAL) {		data_interface = usb_ifnum_to_if(usb_dev, 1);		control_interface = usb_ifnum_to_if(usb_dev, 0);		goto skip_normal_probe;	}		/* normal probing*/	if (!buffer) {		err("Weird descriptor references/n");		return -EINVAL;	}	if (!buflen) {		if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {			dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint/n");			buflen = intf->cur_altsetting->endpoint->extralen;			buffer = intf->cur_altsetting->endpoint->extra;		} else {			err("Zero length descriptor references/n");			return -EINVAL;		}	}	while (buflen > 0) {		if (buffer [1] != USB_DT_CS_INTERFACE) {			err("skipping garbage/n");			goto next_desc;		}		switch (buffer [2]) {			case USB_CDC_UNION_TYPE: /* we've found it */				if (union_header) {					err("More than one union descriptor, skipping ...");					goto next_desc;				}				union_header = (struct usb_cdc_union_desc *)							buffer;				break;			case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/				cfd = (struct usb_cdc_country_functional_desc *)buffer;				break;			case USB_CDC_HEADER_TYPE: /* maybe check version */ 				break; /* for now we ignore it */ 			case USB_CDC_ACM_TYPE:				ac_management_function = buffer[3];				break;			case USB_CDC_CALL_MANAGEMENT_TYPE:				call_management_function = buffer[3];				call_interface_num = buffer[4];				if ((call_management_function & 3) != 3)					err("This device cannot do calls on its own. It is no modem.");				break;			default:				/* there are LOTS more CDC descriptors that				 * could legitimately be found here.				 */				dev_dbg(&intf->dev, "Ignoring descriptor: "						"type %02x, length %d/n",						buffer[2], buffer[0]);				break;			}next_desc:		buflen -= buffer[0];		buffer += buffer[0];	}	if (!union_header) {		if (call_interface_num > 0) {			dev_dbg(&intf->dev,"No union descriptor, using call management descriptor/n");			data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));//.........这里部分代码省略.........

//.........这里部分代码省略.........		case USB_CDC_ACM_TYPE:			/* paranoia:  disambiguate a "real" vendor-specific			 * modem interface from an RNDIS non-modem.			 */			if (rndis) {				struct usb_cdc_acm_descriptor *acm;				acm = (void *) buf;				if (acm->bmCapabilities) {					dev_dbg(&intf->dev,						"ACM capabilities %02x, "						"not really RNDIS?/n",						acm->bmCapabilities);					goto bad_desc;				}			}			break;		case USB_CDC_UNION_TYPE:			if (info->u) {				dev_dbg(&intf->dev, "extra CDC union/n");				goto bad_desc;			}			info->u = (void *) buf;			if (info->u->bLength != sizeof *info->u) {				dev_dbg(&intf->dev, "CDC union len %u/n",					info->u->bLength);				goto bad_desc;			}			/* we need a master/control interface (what we're			 * probed with) and a slave/data interface; union			 * descriptors sort this all out.			 */			info->control = usb_ifnum_to_if(dev->udev,						info->u->bMasterInterface0);			info->data = usb_ifnum_to_if(dev->udev,						info->u->bSlaveInterface0);			if (!info->control || !info->data) {				dev_dbg(&intf->dev,					"master #%u/%p slave #%u/%p/n",					info->u->bMasterInterface0,					info->control,					info->u->bSlaveInterface0,					info->data);				/* fall back to hard-wiring for RNDIS */				if (rndis) {					android_rndis_quirk = true;					goto next_desc;				}				goto bad_desc;			}			if (info->control != intf) {				dev_dbg(&intf->dev, "bogus CDC Union/n");				/* Ambit USB Cable Modem (and maybe others)				 * interchanges master and slave interface.				 */				if (info->data == intf) {					info->data = info->control;					info->control = intf;				} else					goto bad_desc;			}			/* a data interface altsetting does the real i/o */			d = &info->data->cur_altsetting->desc;			if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {

static int usX2Y_create_usbmidi(snd_card_t* card ){	static snd_usb_midi_endpoint_info_t quirk_data_1 = {		.out_ep =0x06,		.in_ep = 0x06,		.out_cables =	0x001,		.in_cables =	0x001	};	static snd_usb_audio_quirk_t quirk_1 = {		.vendor_name =	"TASCAM",		.product_name =	NAME_ALLCAPS,		.ifnum = 	0,       		.type = QUIRK_MIDI_FIXED_ENDPOINT,		.data = &quirk_data_1	};	static snd_usb_midi_endpoint_info_t quirk_data_2 = {		.out_ep =0x06,		.in_ep = 0x06,		.out_cables =	0x003,		.in_cables =	0x003	};	static snd_usb_audio_quirk_t quirk_2 = {		.vendor_name =	"TASCAM",		.product_name =	"US428",		.ifnum = 	0,       		.type = QUIRK_MIDI_FIXED_ENDPOINT,		.data = &quirk_data_2	};	struct usb_device *dev = usX2Y(card)->chip.dev;	struct usb_interface *iface = usb_ifnum_to_if(dev, 0);	snd_usb_audio_quirk_t *quirk = le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ? &quirk_2 : &quirk_1;	snd_printdd("usX2Y_create_usbmidi /n");	return snd_usb_create_midi_interface(&usX2Y(card)->chip, iface, quirk);}static int usX2Y_create_alsa_devices(snd_card_t* card){	int err;	do {		if ((err = usX2Y_create_usbmidi(card)) < 0) {			snd_printk("usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i /n", err);			break;		}		if ((err = usX2Y_audio_create(card)) < 0) 			break;		if ((err = usX2Y_hwdep_pcm_new(card)) < 0)			break;		if ((err = snd_card_register(card)) < 0)			break;	} while (0);	return err;} static int snd_usX2Y_hwdep_dsp_load(snd_hwdep_t *hw, snd_hwdep_dsp_image_t *dsp){	usX2Ydev_t *priv = hw->private_data;	int	lret, err = -EINVAL;	snd_printdd( "dsp_load %s/n", dsp->name);	if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {		struct usb_device* dev = priv->chip.dev;		char *buf = kmalloc(dsp->length, GFP_KERNEL);		if (!buf)			return -ENOMEM;		if (copy_from_user(buf, dsp->image, dsp->length)) {			kfree(buf);			return -EFAULT;		}		err = usb_set_interface(dev, 0, 1);		if (err)			snd_printk("usb_set_interface error /n");		else			err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6*HZ);		kfree(buf);	}	if (err)		return err;	if (dsp->index == 1) {		set_current_state(TASK_UNINTERRUPTIBLE);		schedule_timeout(HZ/4);			// give the device some time 		err = usX2Y_AsyncSeq04_init(priv);		if (err) {			snd_printk("usX2Y_AsyncSeq04_init error /n");			return err;		}		err = usX2Y_In04_init(priv);		if (err) {			snd_printk("usX2Y_In04_init error /n");			return err;		}		err = usX2Y_create_alsa_devices(hw->card);		if (err) {			snd_printk("usX2Y_create_alsa_devices error %i /n", err);			snd_card_free(hw->card);			return err;		}		priv->chip_status |= USX2Y_STAT_CHIP_INIT; //.........这里部分代码省略.........

/** * usb_set_interface - Makes a particular alternate setting be current * @dev: the device whose interface is being updated * @interface: the interface being updated * @alternate: the setting being chosen. * Context: !in_interrupt () * * This is used to enable data transfers on interfaces that may not * be enabled by default.  Not all devices support such configurability. * Only the driver bound to an interface may change its setting. * * Within any given configuration, each interface may have several * alternative settings.  These are often used to control levels of * bandwidth consumption.  For example, the default setting for a high * speed interrupt endpoint may not send more than 64 bytes per microframe, * while interrupt transfers of up to 3KBytes per microframe are legal. * Also, isochronous endpoints may never be part of an * interface's default setting.  To access such bandwidth, alternate * interface settings must be made current. * * Note that in the Linux USB subsystem, bandwidth associated with * an endpoint in a given alternate setting is not reserved until an URB * is submitted that needs that bandwidth.  Some other operating systems * allocate bandwidth early, when a configuration is chosen. * * This call is synchronous, and may not be used in an interrupt context. * Also, drivers must not change altsettings while urbs are scheduled for * endpoints in that interface; all such urbs must first be completed * (perhaps forced by unlinking). * * Returns zero on success, or else the status code returned by the * underlying usb_control_msg() call. */int usb_set_interface(struct usb_device *dev, int interface, int alternate){	struct usb_interface *iface;	struct usb_host_interface *alt;	int ret;	int manual = 0;	if (dev->state == USB_STATE_SUSPENDED)		return -EHOSTUNREACH;	iface = usb_ifnum_to_if(dev, interface);	if (!iface) {		dev_dbg(&dev->dev, "selecting invalid interface %d/n",			interface);		return -EINVAL;	}	alt = usb_altnum_to_altsetting(iface, alternate);	if (!alt) {		warn("selecting invalid altsetting %d", alternate);		return -EINVAL;	}	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),				   USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,				   alternate, interface, NULL, 0, 5000);	/* 9.4.10 says devices don't need this and are free to STALL the	 * request if the interface only has one alternate setting.	 */	if (ret == -EPIPE && iface->num_altsetting == 1) {		dev_dbg(&dev->dev,			"manual set_interface for iface %d, alt %d/n",			interface, alternate);		manual = 1;	} else if (ret < 0)		return ret;	/* FIXME drivers shouldn't need to replicate/bugfix the logic here	 * when they implement async or easily-killable versions of this or	 * other "should-be-internal" functions (like clear_halt).	 * should hcd+usbcore postprocess control requests?	 */	/* prevent submissions using previous endpoint settings */	if (device_is_registered(&iface->dev))		usb_remove_sysfs_intf_files(iface);	usb_disable_interface(dev, iface);	iface->cur_altsetting = alt;	/* If the interface only has one altsetting and the device didn't	 * accept the request, we attempt to carry out the equivalent action	 * by manually clearing the HALT feature for each endpoint in the	 * new altsetting.	 */	if (manual) {		int i;		for (i = 0; i < alt->desc.bNumEndpoints; i++) {			unsigned int epaddr =				alt->endpoint[i].desc.bEndpointAddress;			unsigned int pipe =	__create_pipe(dev, USB_ENDPOINT_NUMBER_MASK & epaddr)	| (usb_endpoint_out(epaddr) ? USB_DIR_OUT : USB_DIR_IN);			usb_clear_halt(dev, pipe);//.........这里部分代码省略.........

/* probes control interface, claims data interface, collects the bulk * endpoints, activates data interface (if needed), maybe sets MTU. * all pure cdc, except for certain firmware workarounds, and knowing * that rndis uses one different rule. */int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf){	u8				*buf = intf->cur_altsetting->extra;	int				len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor	*d;	struct cdc_state		*info = (void *) &dev->data;	int				status;	int				rndis;	bool				android_rndis_quirk = false;	struct usb_driver		*driver = driver_of(intf);	struct usb_cdc_parsed_header header;	if (sizeof(dev->data) < sizeof(*info))		return -EDOM;	/* expect strict spec conformance for the descriptors, but	 * cope with firmware which stores them in the wrong place	 */	if (len == 0 && dev->udev->actconfig->extralen) {		/* Motorola SB4100 (and others: Brad Hards says it's		 * from a Broadcom design) put CDC descriptors here		 */		buf = dev->udev->actconfig->extra;		len = dev->udev->actconfig->extralen;		dev_dbg(&intf->dev, "CDC descriptors on config/n");	}	/* Maybe CDC descriptors are after the endpoint?  This bug has	 * been seen on some 2Wire Inc RNDIS-ish products.	 */	if (len == 0) {		struct usb_host_endpoint	*hep;		hep = intf->cur_altsetting->endpoint;		if (hep) {			buf = hep->extra;			len = hep->extralen;		}		if (len)			dev_dbg(&intf->dev,				"CDC descriptors on endpoint/n");	}	/* this assumes that if there's a non-RNDIS vendor variant	 * of cdc-acm, it'll fail RNDIS requests cleanly.	 */	rndis = (is_rndis(&intf->cur_altsetting->desc) ||		 is_activesync(&intf->cur_altsetting->desc) ||		 is_wireless_rndis(&intf->cur_altsetting->desc) ||		 is_novatel_rndis(&intf->cur_altsetting->desc));	memset(info, 0, sizeof(*info));	info->control = intf;	cdc_parse_cdc_header(&header, intf, buf, len);	info->u = header.usb_cdc_union_desc;	info->header = header.usb_cdc_header_desc;	info->ether = header.usb_cdc_ether_desc;	if (!info->u) {		if (rndis)			goto skip;		else /* in that case a quirk is mandatory */			goto bad_desc;	}	/* we need a master/control interface (what we're	 * probed with) and a slave/data interface; union	 * descriptors sort this all out.	 */	info->control = usb_ifnum_to_if(dev->udev, info->u->bMasterInterface0);	info->data = usb_ifnum_to_if(dev->udev, info->u->bSlaveInterface0);	if (!info->control || !info->data) {		dev_dbg(&intf->dev,			"master #%u/%p slave #%u/%p/n",			info->u->bMasterInterface0,			info->control,			info->u->bSlaveInterface0,			info->data);		/* fall back to hard-wiring for RNDIS */		if (rndis) {			android_rndis_quirk = true;			goto skip;		}		goto bad_desc;	}	if (info->control != intf) {		dev_dbg(&intf->dev, "bogus CDC Union/n");		/* Ambit USB Cable Modem (and maybe others)		 * interchanges master and slave interface.		 */		if (info->data == intf) {			info->data = info->control;			info->control = intf;		} else			goto bad_desc;//.........这里部分代码省略.........

static int konicawc_start_data(struct uvd *uvd){	struct usb_device *dev = uvd->dev;	int i, errFlag;	struct konicawc *cam = (struct konicawc *)uvd->user_data;	int pktsz;	struct usb_interface *intf;	struct usb_host_interface *interface = NULL;	intf = usb_ifnum_to_if(dev, uvd->iface);	if (intf)		interface = usb_altnum_to_altsetting(intf,				spd_to_iface[cam->speed]);	if (!interface)		return -ENXIO;	pktsz = le16_to_cpu(interface->endpoint[1].desc.wMaxPacketSize);	DEBUG(1, "pktsz = %d", pktsz);	if (!CAMERA_IS_OPERATIONAL(uvd)) {		err("Camera is not operational");		return -EFAULT;	}	uvd->curframe = -1;	konicawc_camera_on(uvd);	/* Alternate interface 1 is is the biggest frame size */	i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);	if (i < 0) {		err("usb_set_interface error");		uvd->last_error = i;		return -EBUSY;	}	/* We double buffer the Iso lists */	for (i=0; i < USBVIDEO_NUMSBUF; i++) {		int j, k;		struct urb *urb = uvd->sbuf[i].urb;		urb->dev = dev;		urb->context = uvd;		urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);		urb->interval = 1;		urb->transfer_flags = URB_ISO_ASAP;		urb->transfer_buffer = uvd->sbuf[i].data;		urb->complete = konicawc_isoc_irq;		urb->number_of_packets = FRAMES_PER_DESC;		urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;		for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {			urb->iso_frame_desc[j].offset = k;			urb->iso_frame_desc[j].length = pktsz;		}		urb = cam->sts_urb[i];		urb->dev = dev;		urb->context = uvd;		urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp-1);		urb->interval = 1;		urb->transfer_flags = URB_ISO_ASAP;		urb->transfer_buffer = cam->sts_buf[i];		urb->complete = konicawc_isoc_irq;		urb->number_of_packets = FRAMES_PER_DESC;		urb->transfer_buffer_length = FRAMES_PER_DESC;		for (j=0; j < FRAMES_PER_DESC; j++) {			urb->iso_frame_desc[j].offset = j;			urb->iso_frame_desc[j].length = 1;		}	}	cam->last_data_urb = NULL;	/* Submit all URBs */	for (i=0; i < USBVIDEO_NUMSBUF; i++) {		errFlag = usb_submit_urb(cam->sts_urb[i], GFP_KERNEL);		if (errFlag)			err("usb_submit_isoc(%d) ret %d", i, errFlag);		errFlag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);		if (errFlag)			err ("usb_submit_isoc(%d) ret %d", i, errFlag);	}	uvd->streaming = 1;	DEBUG(1, "streaming=1 video_endp=$%02x", uvd->video_endp);	return 0;}

int cdc_ncm_bind(struct if_usb_devdata *pipe_data,		struct usb_interface *intf, struct usb_link_device *usb_ld){	struct cdc_ncm_ctx *ctx;	struct usb_driver *usbdrv = to_usb_driver(intf->dev.driver);	struct usb_device *usbdev = interface_to_usbdev(intf);	unsigned char *buf = intf->cur_altsetting->extra;	int buflen = intf->cur_altsetting->extralen;	const struct usb_cdc_union_desc *union_desc;	int temp;	u8 iface_no;	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);	if (ctx == NULL)		return -ENODEV;	hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;	ctx->bh.data = (unsigned long)pipe_data;	ctx->bh.func = cdc_ncm_txpath_bh;	atomic_set(&ctx->stop, 0);	spin_lock_init(&ctx->mtx);	/* store ctx pointer in device data field */	pipe_data->sedata = (void *)ctx;	ctx->intf = intf;	/* parse through descriptors associated with control interface */	while ((buflen > 0) && (buf[0] > 2) && (buf[0] <= buflen)) {		if (buf[1] == USB_DT_CS_INTERFACE) {			switch (buf[2]) {			case USB_CDC_UNION_TYPE:				if (buf[0] < sizeof(*union_desc))					break;				union_desc =					(const struct usb_cdc_union_desc *)buf;				ctx->control = usb_ifnum_to_if(usbdev,					union_desc->bMasterInterface0);				ctx->data = usb_ifnum_to_if(usbdev,					union_desc->bSlaveInterface0);				break;			case USB_CDC_ETHERNET_TYPE:				if (buf[0] < sizeof(*(ctx->ether_desc)))					break;				ctx->ether_desc =					(const struct usb_cdc_ether_desc *)buf;				break;			case USB_CDC_NCM_TYPE:				if (buf[0] < sizeof(*(ctx->func_desc)))					break;				ctx->func_desc =					(const struct usb_cdc_ncm_desc *)buf;				break;			default:				break;			}		}		temp = buf[0];		buf += temp;		buflen -= temp;	}	/* check if we got everything */	if ((ctx->control == NULL) || (ctx->data == NULL) ||	    (ctx->ether_desc == NULL) || (ctx->control != intf))		goto error;	pipe_data->usbdev = usb_get_dev(usbdev);	pipe_data->usb_ld = usb_ld;	pipe_data->disconnected = 0;	pipe_data->state = STATE_RESUMED;	/* claim interfaces, if any */	temp = usb_driver_claim_interface(usbdrv, ctx->data, pipe_data);	if (temp)		goto error;	iface_no = ctx->data->cur_altsetting->desc.bInterfaceNumber;	/* reset data interface */	temp = usb_set_interface(usbdev, iface_no, 0);	if (temp)		goto error2;	/* initialize data interface */	if (cdc_ncm_setup(pipe_data))		goto error2;	/* configure data interface */	temp = usb_set_interface(usbdev, iface_no, 1);//.........这里部分代码省略.........

irqreturn_t baseband_xmm_power_ipc_ap_wake_irq(int irq, void *dev_id){	int value;	struct baseband_power_platform_data *data = baseband_power_driver_data;		value = gpio_get_value(baseband_power_driver_data->modem.xmm.ipc_ap_wake);	pr_debug("%s g(%d), wake_st(%d)/n", __func__, value, ipc_ap_wake_state);	if (ipc_ap_wake_state < IPC_AP_WAKE_IRQ_READY) {		pr_err("%s - spurious irq/n", __func__);	} else if (ipc_ap_wake_state == IPC_AP_WAKE_IRQ_READY) {		if (!value) {			pr_debug("%s - IPC_AP_WAKE_INIT1" " - got falling edge/n", __func__);			/* go to IPC_AP_WAKE_INIT1 state */			ipc_ap_wake_state = IPC_AP_WAKE_INIT1;			/* queue work */			queue_work(workqueue, &init1_work);		} else {			pr_debug("%s - IPC_AP_WAKE_INIT1" " - wait for falling edge/n",	__func__);		}	} else if (ipc_ap_wake_state == IPC_AP_WAKE_INIT1) {		if (!value) {			pr_debug("%s - IPC_AP_WAKE_INIT2" " - wait for rising edge/n",__func__);		} else {			pr_debug("%s - IPC_AP_WAKE_INIT2" " - got rising edge/n",__func__);			/* go to IPC_AP_WAKE_INIT2 state */			ipc_ap_wake_state = IPC_AP_WAKE_INIT2;			/* queue work */			queue_work(workqueue, &init2_work);		}	} else {		if (!value) {			pr_debug("%s - falling/n", __func__);			/* First check it a CP ack or CP wake  */			value = gpio_get_value(data->modem.xmm.ipc_bb_wake);			if (value) {				pr_debug("cp ack for bb_wake/n");				ipc_ap_wake_state = IPC_AP_WAKE_L;				return IRQ_HANDLED;			}			spin_lock(&xmm_lock);			wakeup_pending = true;			if (system_suspending) {				spin_unlock(&xmm_lock);				pr_debug("Set wakeup_pending = 1 in system_" " suspending!!!/n");			} else {				if (baseband_xmm_powerstate == BBXMM_PS_L3) {					spin_unlock(&xmm_lock);					pr_debug("PM_ST : CP L3 -> L0/n");				} else if (baseband_xmm_powerstate == BBXMM_PS_L2) {					CP_initiated_L2toL0 = true;					spin_unlock(&xmm_lock);					baseband_xmm_set_power_status(BBXMM_PS_L2TOL0);				} else {					CP_initiated_L2toL0 = true;					spin_unlock(&xmm_lock);				}			}			/* save gpio state */			ipc_ap_wake_state = IPC_AP_WAKE_L;		} else {			pr_debug("%s - rising/n", __func__);			value = gpio_get_value(data->modem.xmm.ipc_hsic_active);			//pr_debug("GPIO [R]: Host_active = %d /n",value); 			if (!value) {				pr_debug("host active low: ignore request/n");				ipc_ap_wake_state = IPC_AP_WAKE_H;				return IRQ_HANDLED;			}			value = gpio_get_value(data->modem.xmm.ipc_bb_wake);			//pr_debug("GPIO [R]: Slave_wakeup = %d /n", value); 			if (value) {				/* Clear the slave wakeup request */				gpio_set_value(data->modem.xmm.ipc_bb_wake, 0);				pr_debug("GPIO [W]: Slave_wake -> 0 /n"); 			}			if (reenable_autosuspend && usbdev) {			      reenable_autosuspend = false;				struct usb_interface *intf;				intf = usb_ifnum_to_if(usbdev, 0);				if (usb_autopm_get_interface_async(intf) >= 0) {					pr_debug("get_interface_async succeeded"	" - call put_interface/n");					usb_autopm_put_interface_async(intf);				} else {					pr_debug("get_interface_async failed" " - do not call put_interface/n");				}			      			}			modem_sleep_flag = false;			baseband_xmm_set_power_status(BBXMM_PS_L0);			if (short_autosuspend && enable_short_autosuspend &&						baseband_xmm_powerstate == BBXMM_PS_L0 &&						&usbdev->dev) 			{				pr_debug("set autosuspend delay %d ms/n",SHORT_AUTOSUSPEND_DELAY);				queue_work(workqueue_susp, &work_shortsusp);							} 			/* save gpio state */			ipc_ap_wake_state = IPC_AP_WAKE_H;		}	}//.........这里部分代码省略.........

static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf){	int status = -1;	u8 *buf = intf->cur_altsetting->extra;	int len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;	struct usb_cdc_union_desc *cdc_union;	struct usb_cdc_ether_desc *cdc_ether;	struct usb_driver *driver = driver_of(intf);	struct qmi_wwan_state *info = (void *)&dev->data;	struct usb_cdc_parsed_header hdr;	BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) <		      sizeof(struct qmi_wwan_state)));	/* set up initial state */	info->control = intf;	info->data = intf;	/* and a number of CDC descriptors */	cdc_parse_cdc_header(&hdr, intf, buf, len);	cdc_union = hdr.usb_cdc_union_desc;	cdc_ether = hdr.usb_cdc_ether_desc;	/* Use separate control and data interfaces if we found a CDC Union */	if (cdc_union) {		info->data = usb_ifnum_to_if(dev->udev,					     cdc_union->bSlaveInterface0);		if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 ||		    !info->data) {			dev_err(&intf->dev,				"bogus CDC Union: master=%u, slave=%u/n",				cdc_union->bMasterInterface0,				cdc_union->bSlaveInterface0);			/* ignore and continue... */			cdc_union = NULL;			info->data = intf;		}	}	/* errors aren't fatal - we can live with the dynamic address */	if (cdc_ether) {		dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);		usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);	}	/* claim data interface and set it up */	if (info->control != info->data) {		status = usb_driver_claim_interface(driver, info->data, dev);		if (status < 0)			goto err;	}	status = qmi_wwan_register_subdriver(dev);	if (status < 0 && info->control != info->data) {		usb_set_intfdata(info->data, NULL);		usb_driver_release_interface(driver, info->data);	}	/* disabling remote wakeup on MDM9x30 devices has the same	 * effect as clearing DTR. The device will not respond to QMI	 * requests until we set DTR again.  This is similar to a	 * QMI_CTL SYNC request, clearing a lot of firmware state	 * including the client ID allocations.	 *	 * Our usage model allows a session to span multiple	 * open/close events, so we must prevent the firmware from	 * clearing out state the clients might need.	 *	 * MDM9x30 is the first QMI chipset with USB3 support. Abuse	 * this fact to enable the quirk.	 */	if (le16_to_cpu(dev->udev->descriptor.bcdUSB) >= 0x0201) {		qmi_wwan_manage_power(dev, 1);		qmi_wwan_change_dtr(dev, true);	}	/* Never use the same address on both ends of the link, even if the	 * buggy firmware told us to. Or, if device is assigned the well-known	 * buggy firmware MAC address, replace it with a random address,	 */	if (ether_addr_equal(dev->net->dev_addr, default_modem_addr) ||	    ether_addr_equal(dev->net->dev_addr, buggy_fw_addr))		eth_hw_addr_random(dev->net);	/* make MAC addr easily distinguishable from an IP header */	if (possibly_iphdr(dev->net->dev_addr)) {		dev->net->dev_addr[0] |= 0x02;	/* set local assignment bit */		dev->net->dev_addr[0] &= 0xbf;	/* clear "IP" bit */	}	dev->net->netdev_ops = &qmi_wwan_netdev_ops;	dev->net->sysfs_groups[0] = &qmi_wwan_sysfs_attr_group;err:	return status;}

int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting){	const struct usb_cdc_union_desc *union_desc = NULL;	struct cdc_ncm_ctx *ctx;	struct usb_driver *driver;	u8 *buf;	int len;	int temp;	u8 iface_no;	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);	if (!ctx)		return -ENOMEM;	hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;	ctx->bh.data = (unsigned long)dev;	ctx->bh.func = cdc_ncm_txpath_bh;	atomic_set(&ctx->stop, 0);	spin_lock_init(&ctx->mtx);	/* store ctx pointer in device data field */	dev->data[0] = (unsigned long)ctx;	/* only the control interface can be successfully probed */	ctx->control = intf;	/* get some pointers */	driver = driver_of(intf);	buf = intf->cur_altsetting->extra;	len = intf->cur_altsetting->extralen;	/* parse through descriptors associated with control interface */	while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) {		if (buf[1] != USB_DT_CS_INTERFACE)			goto advance;		switch (buf[2]) {		case USB_CDC_UNION_TYPE:			if (buf[0] < sizeof(*union_desc))				break;			union_desc = (const struct usb_cdc_union_desc *)buf;			/* the master must be the interface we are probing */			if (intf->cur_altsetting->desc.bInterfaceNumber !=			    union_desc->bMasterInterface0) {				dev_dbg(&intf->dev, "bogus CDC Union/n");				goto error;			}			ctx->data = usb_ifnum_to_if(dev->udev,						    union_desc->bSlaveInterface0);			break;		case USB_CDC_ETHERNET_TYPE:			if (buf[0] < sizeof(*(ctx->ether_desc)))				break;			ctx->ether_desc =					(const struct usb_cdc_ether_desc *)buf;			break;		case USB_CDC_NCM_TYPE:			if (buf[0] < sizeof(*(ctx->func_desc)))				break;			ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf;			break;		case USB_CDC_MBIM_TYPE:			if (buf[0] < sizeof(*(ctx->mbim_desc)))				break;			ctx->mbim_desc = (const struct usb_cdc_mbim_desc *)buf;			break;		case USB_CDC_MBIM_EXTENDED_TYPE:			if (buf[0] < sizeof(*(ctx->mbim_extended_desc)))				break;			ctx->mbim_extended_desc =				(const struct usb_cdc_mbim_extended_desc *)buf;			break;		default:			break;		}advance:		/* advance to next descriptor */		temp = buf[0];		buf += temp;		len -= temp;	}	/* some buggy devices have an IAD but no CDC Union */	if (!union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) {		ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1);		dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD/n");	}//.........这里部分代码省略.........

int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting){	struct cdc_ncm_ctx *ctx;	struct usb_driver *driver;	u8 *buf;	int len;	int temp;	u8 iface_no;	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);	if (!ctx)		return -ENOMEM;	hrtimer_init(&ctx->tx_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	ctx->tx_timer.function = &cdc_ncm_tx_timer_cb;	ctx->bh.data = (unsigned long)ctx;	ctx->bh.func = cdc_ncm_txpath_bh;	atomic_set(&ctx->stop, 0);	spin_lock_init(&ctx->mtx);	ctx->netdev = dev->net;	/* store ctx pointer in device data field */	dev->data[0] = (unsigned long)ctx;	/* get some pointers */	driver = driver_of(intf);	buf = intf->cur_altsetting->extra;	len = intf->cur_altsetting->extralen;	ctx->udev = dev->udev;	ctx->intf = intf;	/* parse through descriptors associated with control interface */	while ((len > 0) && (buf[0] > 2) && (buf[0] <= len)) {		if (buf[1] != USB_DT_CS_INTERFACE)			goto advance;		switch (buf[2]) {		case USB_CDC_UNION_TYPE:			if (buf[0] < sizeof(*(ctx->union_desc)))				break;			ctx->union_desc =					(const struct usb_cdc_union_desc *)buf;			ctx->control = usb_ifnum_to_if(dev->udev,					ctx->union_desc->bMasterInterface0);			ctx->data = usb_ifnum_to_if(dev->udev,					ctx->union_desc->bSlaveInterface0);			break;		case USB_CDC_ETHERNET_TYPE:			if (buf[0] < sizeof(*(ctx->ether_desc)))				break;			ctx->ether_desc =					(const struct usb_cdc_ether_desc *)buf;			dev->hard_mtu =				le16_to_cpu(ctx->ether_desc->wMaxSegmentSize);			if (dev->hard_mtu < CDC_NCM_MIN_DATAGRAM_SIZE)				dev->hard_mtu =	CDC_NCM_MIN_DATAGRAM_SIZE;			else if (dev->hard_mtu > CDC_NCM_MAX_DATAGRAM_SIZE)				dev->hard_mtu =	CDC_NCM_MAX_DATAGRAM_SIZE;			break;		case USB_CDC_NCM_TYPE:			if (buf[0] < sizeof(*(ctx->func_desc)))				break;			ctx->func_desc = (const struct usb_cdc_ncm_desc *)buf;			break;		case USB_CDC_MBIM_TYPE:			if (buf[0] < sizeof(*(ctx->mbim_desc)))				break;			ctx->mbim_desc = (const struct usb_cdc_mbim_desc *)buf;			break;		default:			break;		}advance:		/* advance to next descriptor */		temp = buf[0];		buf += temp;		len -= temp;	}	/* some buggy devices have an IAD but no CDC Union */	if (!ctx->union_desc && intf->intf_assoc && intf->intf_assoc->bInterfaceCount == 2) {		ctx->control = intf;		ctx->data = usb_ifnum_to_if(dev->udev, intf->cur_altsetting->desc.bInterfaceNumber + 1);		dev_dbg(&intf->dev, "CDC Union missing - got slave from IAD/n");	}	/* check if we got everything */	if ((ctx->control == NULL) || (ctx->data == NULL) ||//.........这里部分代码省略.........

static int usb_dio_probe(struct usb_interface *intf, const struct usb_device_id *id) {  struct usb_cdc_union_desc *union_header = NULL;	unsigned char *buffer = intf->altsetting->extra;	int buflen = intf->altsetting->extralen;	struct usb_interface *control_interface;	struct usb_interface *data_interface;	struct usb_device *usb_dev = interface_to_usbdev(intf);  int retval = 0;    usb_dio_dev *dev;    /* prevent usb_dio_probe() from racing usb_dio_disconnect() */  lock_kernel();    FUNC_HI();  dev = kmalloc(sizeof(usb_dio_dev), GFP_KERNEL);  if (dev == NULL) {    err("Out of Memory");    unlock_kernel();    FUNC_ERR();    return -ENOMEM;  }	memset(dev, 0x00, sizeof (usb_dio_dev));  dev->dev = usb_get_dev(interface_to_usbdev(intf));	kref_init(&(dev->kref));  usb_set_intfdata(intf, dev);    printk(KERN_ALERT "%s: === Starting device probe ===/n", usb_dio_driver.name);    if (!buflen) {    printk(KERN_ALERT "%s: === Invalid / unwanted device ===/n", usb_dio_driver.name);    unlock_kernel();    FUNC_ERR();    return -EINVAL;  }  DPRINTK(KERN_ALERT "%s: == Chunk size    = %2d ==/n", usb_dio_driver.name, buffer[0]);  DPRINTK(KERN_ALERT "%s: == Buffer length = %2d ==/n", usb_dio_driver.name, buflen);	while (buflen > 0) {		switch (buffer[2]) {      case USB_CDC_UNION_TYPE: /* we've found it */        DPRINTK(KERN_ALERT "%s: ==== USB_CDC_UNION_TYPE ==============/n", usb_dio_driver.name);        if (union_header) {          DPRINTK(KERN_ALERT "%s: ===== More than one union header! =====/n", usb_dio_driver.name);          break;        }        union_header = (struct usb_cdc_union_desc *)buffer;        break;      default:        DPRINTK(KERN_ALERT "%s: ==== Unwanted default... =============/n", usb_dio_driver.name);        break;		}    DPRINTK(KERN_ALERT "%s: === continuation with %2d remaining... ===/n", usb_dio_driver.name, buflen - buffer[0]);		buflen -= buffer[0];		buffer += buffer[0];	}  DPRINTK(KERN_ALERT "%s: == complete with %2d remaining ==/n", usb_dio_driver.name, buflen);  control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);  data_interface = usb_ifnum_to_if(usb_dev, union_header->bSlaveInterface0);  if (!control_interface || !data_interface) {    printk(KERN_ALERT "%s: === missing interface(s)! ===/n", usb_dio_driver.name);    unlock_kernel();    FUNC_ERR();    return -ENODEV;  }  sema_init(&dev->buffer_sem,1);  sema_init(&dev->buffer_empty_sem,1);  dev->bulk_in = &(data_interface->cur_altsetting->endpoint[0].desc);  dev->bulk_in_urb = NULL;  dev->bulk_in_size = dev->bulk_in->wMaxPacketSize;  dev->bulk_in_endpointAddr = dev->bulk_in->bEndpointAddress & 0xF;  dev->bulk_in_endpointPipe = usb_rcvbulkpipe(dev->dev,dev->bulk_in_endpointAddr);  dev->bulk_in_buffer = kmalloc(dev->bulk_in->wMaxPacketSize, GFP_KERNEL);  dev->bulk_in_workqueue = create_singlethread_workqueue("Rx");  INIT_WORK(&(dev->bulk_in_work.work),(void(*)(struct work_struct *))diodev_rx_work);  dev->bulk_in_work.arg = NULL;  dev->bulk_in_work.dev = dev;    dev->bulk_out = &(data_interface->cur_altsetting->endpoint[1].desc);  dev->bulk_out_endpointAddr = dev->bulk_out->bEndpointAddress & 0xF;  dev->bulk_out_endpointPipe = usb_sndbulkpipe(dev->dev,dev->bulk_out_endpointAddr);  dev->bulk_out_cb_urb_chain = NULL;  sema_init(&dev->bulk_out_cb_urb_chain_sem,1);  dev->bulk_out_urb_chain = NULL;  sema_init(&dev->bulk_out_urb_chain_sem,1);  dev->bulk_out_workqueue = create_singlethread_workqueue("Tx");  INIT_WORK(&(dev->bulk_out_work.work),(void(*)(struct work_struct *))diodev_write_work);  dev->bulk_out_work.arg = NULL;  dev->bulk_out_work.dev = dev;    dev->bulk_ctrl = &(control_interface->cur_altsetting->endpoint[0].desc);  dev->bulk_ctrl_endpointAddr = dev->bulk_ctrl->bEndpointAddress & 0xF;    retval = usb_register_dev(intf, &usb_dio_class);  if (retval) {    printk(KERN_ALERT "%s: Not able to get a minor for this device.../n", usb_dio_driver.name);    usb_set_intfdata(intf, NULL);//.........这里部分代码省略.........

static int pwc_isoc_init(struct pwc_device *pdev){	struct usb_device *udev;	struct urb *urb;	int i, j, ret;	struct usb_interface *intf;	struct usb_host_interface *idesc = NULL;	int compression = 0; /* 0..3 = uncompressed..high */	if (pdev->iso_init)		return 0;	pdev->vsync = 0;	pdev->vlast_packet_size = 0;	pdev->fill_buf = NULL;	pdev->vframe_count = 0;	pdev->visoc_errors = 0;	udev = pdev->udev;retry:	/* We first try with low compression and then retry with a higher	   compression setting if there is not enough bandwidth. */	ret = pwc_set_video_mode(pdev, pdev->width, pdev->height,				 pdev->vframes, &compression);	/* Get the current alternate interface, adjust packet size */	intf = usb_ifnum_to_if(udev, 0);	if (intf)		idesc = usb_altnum_to_altsetting(intf, pdev->valternate);	if (!idesc)		return -EIO;	/* Search video endpoint */	pdev->vmax_packet_size = -1;	for (i = 0; i < idesc->desc.bNumEndpoints; i++) {		if ((idesc->endpoint[i].desc.bEndpointAddress & 0xF) == pdev->vendpoint) {			pdev->vmax_packet_size = le16_to_cpu(idesc->endpoint[i].desc.wMaxPacketSize);			break;		}	}	if (pdev->vmax_packet_size < 0 || pdev->vmax_packet_size > ISO_MAX_FRAME_SIZE) {		PWC_ERROR("Failed to find packet size for video endpoint in current alternate setting./n");		return -ENFILE; /* Odd error, that should be noticeable */	}	/* Set alternate interface */	PWC_DEBUG_OPEN("Setting alternate interface %d/n", pdev->valternate);	ret = usb_set_interface(pdev->udev, 0, pdev->valternate);	if (ret == -ENOSPC && compression < 3) {		compression++;		goto retry;	}	if (ret < 0)		return ret;	/* Allocate and init Isochronuous urbs */	for (i = 0; i < MAX_ISO_BUFS; i++) {		urb = usb_alloc_urb(ISO_FRAMES_PER_DESC, GFP_KERNEL);		if (urb == NULL) {			PWC_ERROR("Failed to allocate urb %d/n", i);			pdev->iso_init = 1;			pwc_isoc_cleanup(pdev);			return -ENOMEM;		}		pdev->urbs[i] = urb;		PWC_DEBUG_MEMORY("Allocated URB at 0x%p/n", urb);		urb->interval = 1; // devik		urb->dev = udev;		urb->pipe = usb_rcvisocpipe(udev, pdev->vendpoint);		urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;		urb->transfer_buffer = usb_alloc_coherent(udev,							  ISO_BUFFER_SIZE,							  GFP_KERNEL,							  &urb->transfer_dma);		if (urb->transfer_buffer == NULL) {			PWC_ERROR("Failed to allocate urb buffer %d/n", i);			pdev->iso_init = 1;			pwc_isoc_cleanup(pdev);			return -ENOMEM;		}		urb->transfer_buffer_length = ISO_BUFFER_SIZE;		urb->complete = pwc_isoc_handler;		urb->context = pdev;		urb->start_frame = 0;		urb->number_of_packets = ISO_FRAMES_PER_DESC;		for (j = 0; j < ISO_FRAMES_PER_DESC; j++) {			urb->iso_frame_desc[j].offset = j * ISO_MAX_FRAME_SIZE;			urb->iso_frame_desc[j].length = pdev->vmax_packet_size;		}	}	/* link */	for (i = 0; i < MAX_ISO_BUFS; i++) {		ret = usb_submit_urb(pdev->urbs[i], GFP_KERNEL);		if (ret == -ENOSPC && compression < 3) {			compression++;			pdev->iso_init = 1;			pwc_isoc_cleanup(pdev);//.........这里部分代码省略.........

static int usX2Y_create_usbmidi(struct snd_card *card){    static struct snd_usb_midi_endpoint_info quirk_data_1 = {        .out_ep = 0x06,        .in_ep = 0x06,        .out_cables =	0x001,        .in_cables =	0x001    };    static struct snd_usb_audio_quirk quirk_1 = {        .vendor_name =	"TASCAM",        .product_name =	NAME_ALLCAPS,        .ifnum = 	0,        .type = QUIRK_MIDI_FIXED_ENDPOINT,        .data = &quirk_data_1    };    static struct snd_usb_midi_endpoint_info quirk_data_2 = {        .out_ep = 0x06,        .in_ep = 0x06,        .out_cables =	0x003,        .in_cables =	0x003    };    static struct snd_usb_audio_quirk quirk_2 = {        .vendor_name =	"TASCAM",        .product_name =	"US428",        .ifnum = 	0,        .type = QUIRK_MIDI_FIXED_ENDPOINT,        .data = &quirk_data_2    };    struct usb_device *dev = usX2Y(card)->dev;    struct usb_interface *iface = usb_ifnum_to_if(dev, 0);    struct snd_usb_audio_quirk *quirk =        le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ?        &quirk_2 : &quirk_1;    snd_printdd("usX2Y_create_usbmidi /n");    return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk);}static int usX2Y_create_alsa_devices(struct snd_card *card){    int err;    do {        if ((err = usX2Y_create_usbmidi(card)) < 0) {            snd_printk(KERN_ERR "usX2Y_create_alsa_devices: usX2Y_create_usbmidi error %i /n", err);            break;        }        if ((err = usX2Y_audio_create(card)) < 0)            break;        if ((err = usX2Y_hwdep_pcm_new(card)) < 0)            break;        if ((err = snd_card_register(card)) < 0)            break;    } while (0);    return err;}static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,                                    struct snd_hwdep_dsp_image *dsp){    struct usX2Ydev *priv = hw->private_data;    int	lret, err = -EINVAL;    snd_printdd( "dsp_load %s/n", dsp->name);    if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {        struct usb_device* dev = priv->dev;        char *buf;        buf = memdup_user(dsp->image, dsp->length);        if (IS_ERR(buf))            return PTR_ERR(buf);        err = usb_set_interface(dev, 0, 1);        if (err)            snd_printk(KERN_ERR "usb_set_interface error /n");        else            err = usb_bulk_msg(dev, usb_sndbulkpipe(dev, 2), buf, dsp->length, &lret, 6000);        kfree(buf);    }    if (err)        return err;    if (dsp->index == 1) {        msleep(250);				// give the device some time        err = usX2Y_AsyncSeq04_init(priv);        if (err) {            snd_printk(KERN_ERR "usX2Y_AsyncSeq04_init error /n");            return err;        }        err = usX2Y_In04_init(priv);        if (err) {            snd_printk(KERN_ERR "usX2Y_In04_init error /n");            return err;        }        err = usX2Y_create_alsa_devices(hw->card);        if (err) {            snd_printk(KERN_ERR "usX2Y_create_alsa_devices error %i /n", err);            snd_card_free(hw->card);            return err;        }//.........这里部分代码省略.........

static int speedtch_upload_firmware(struct speedtch_instance_data *instance,				     const struct firmware *fw1,				     const struct firmware *fw2){	unsigned char *buffer;	struct usbatm_data *usbatm = instance->usbatm;	struct usb_device *usb_dev = usbatm->usb_dev;	int actual_length;	int ret = 0;	int offset;	usb_dbg(usbatm, "%s entered/n", __func__);	if (!(buffer = (unsigned char *)__get_free_page(GFP_KERNEL))) {		ret = -ENOMEM;		usb_dbg(usbatm, "%s: no memory for buffer!/n", __func__);		goto out;	}	if (!usb_ifnum_to_if(usb_dev, 2)) {		ret = -ENODEV;		usb_dbg(usbatm, "%s: interface not found!/n", __func__);		goto out_free;	}	/* URB 7 */	if (dl_512_first) {	/* some modems need a read before writing the firmware */		ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),				   buffer, 0x200, &actual_length, 2000);		if (ret < 0 && ret != -ETIMEDOUT)			usb_warn(usbatm, "%s: read BLOCK0 from modem failed (%d)!/n", __func__, ret);		else			usb_dbg(usbatm, "%s: BLOCK0 downloaded (%d bytes)/n", __func__, ret);	}	/* URB 8 : both leds are static green */	for (offset = 0; offset < fw1->size; offset += PAGE_SIZE) {		int thislen = min_t(int, PAGE_SIZE, fw1->size - offset);		memcpy(buffer, fw1->data + offset, thislen);		ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),				   buffer, thislen, &actual_length, DATA_TIMEOUT);		if (ret < 0) {			usb_err(usbatm, "%s: write BLOCK1 to modem failed (%d)!/n", __func__, ret);			goto out_free;		}		usb_dbg(usbatm, "%s: BLOCK1 uploaded (%zu bytes)/n", __func__, fw1->size);	}	/* USB led blinking green, ADSL led off */	/* URB 11 */	ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),			   buffer, 0x200, &actual_length, DATA_TIMEOUT);	if (ret < 0) {		usb_err(usbatm, "%s: read BLOCK2 from modem failed (%d)!/n", __func__, ret);		goto out_free;	}	usb_dbg(usbatm, "%s: BLOCK2 downloaded (%d bytes)/n", __func__, actual_length);	/* URBs 12 to 139 - USB led blinking green, ADSL led off */	for (offset = 0; offset < fw2->size; offset += PAGE_SIZE) {		int thislen = min_t(int, PAGE_SIZE, fw2->size - offset);		memcpy(buffer, fw2->data + offset, thislen);		ret = usb_bulk_msg(usb_dev, usb_sndbulkpipe(usb_dev, ENDPOINT_FIRMWARE),				   buffer, thislen, &actual_length, DATA_TIMEOUT);		if (ret < 0) {			usb_err(usbatm, "%s: write BLOCK3 to modem failed (%d)!/n", __func__, ret);			goto out_free;		}	}	usb_dbg(usbatm, "%s: BLOCK3 uploaded (%zu bytes)/n", __func__, fw2->size);	/* USB led static green, ADSL led static red */	/* URB 142 */	ret = usb_bulk_msg(usb_dev, usb_rcvbulkpipe(usb_dev, ENDPOINT_FIRMWARE),			   buffer, 0x200, &actual_length, DATA_TIMEOUT);	if (ret < 0) {		usb_err(usbatm, "%s: read BLOCK4 from modem failed (%d)!/n", __func__, ret);		goto out_free;	}	/* success */	usb_dbg(usbatm, "%s: BLOCK4 downloaded (%d bytes)/n", __func__, actual_length);	/* Delay to allow firmware to start up. We can do this here	   because we're in our own kernel thread anyway. */	msleep_interruptible(1000);	if ((ret = usb_set_interface(usb_dev, INTERFACE_DATA, instance->params.altsetting)) < 0) {		usb_err(usbatm, "%s: setting interface to %d failed (%d)!/n", __func__, instance->params.altsetting, ret);		goto out_free;	}//.........这里部分代码省略.........

//.........这里部分代码省略.........	if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)		return -ENODEV;	data->cmdreq_type = USB_TYPE_CLASS;	data->udev = interface_to_usbdev(intf);	data->intf = intf;	spin_lock_init(&data->lock);	INIT_WORK(&data->work, btusb_work);	INIT_WORK(&data->waker, btusb_waker);	spin_lock_init(&data->txlock);	init_usb_anchor(&data->tx_anchor);	init_usb_anchor(&data->intr_anchor);	init_usb_anchor(&data->bulk_anchor);	init_usb_anchor(&data->isoc_anchor);	init_usb_anchor(&data->deferred);	hdev = hci_alloc_dev();	if (!hdev)		return -ENOMEM;	hdev->bus = HCI_USB;	hci_set_drvdata(hdev, data);	data->hdev = hdev;	SET_HCIDEV_DEV(hdev, &intf->dev);	hdev->open   = btusb_open;	hdev->close  = btusb_close;	hdev->flush  = btusb_flush;	hdev->send   = btusb_send_frame;	hdev->notify = btusb_notify;	if (id->driver_info & BTUSB_BCM92035)		hdev->setup = btusb_setup_bcm92035;	if (id->driver_info & BTUSB_INTEL)		hdev->setup = btusb_setup_intel;	/* Interface numbers are hardcoded in the specification */	data->isoc = usb_ifnum_to_if(data->udev, 1);	if (!reset)		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);	if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {		if (!disable_scofix)			set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);	}	if (id->driver_info & BTUSB_BROKEN_ISOC)		data->isoc = NULL;	if (id->driver_info & BTUSB_DIGIANSWER) {		data->cmdreq_type = USB_TYPE_VENDOR;		set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);	}	if (id->driver_info & BTUSB_CSR) {		struct usb_device *udev = data->udev;		/* Old firmware would otherwise execute USB reset */		if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)			set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);	}	if (id->driver_info & BTUSB_SNIFFER) {		struct usb_device *udev = data->udev;		/* New sniffer firmware has crippled HCI interface */		if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)			set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);		data->isoc = NULL;	}	if (data->isoc) {		err = usb_driver_claim_interface(&btusb_driver,							data->isoc, data);		if (err < 0) {			hci_free_dev(hdev);			return err;		}	}	err = hci_register_dev(hdev);	if (err < 0) {		hci_free_dev(hdev);		return err;	}	usb_set_intfdata(intf, data);	usb_enable_autosuspend(data->udev);	return 0;}

static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf){	int status = -1;	u8 *buf = intf->cur_altsetting->extra;	int len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;	struct usb_cdc_union_desc *cdc_union = NULL;	struct usb_cdc_ether_desc *cdc_ether = NULL;	u32 found = 0;	struct usb_driver *driver = driver_of(intf);	struct qmi_wwan_state *info = (void *)&dev->data;	BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) <		      sizeof(struct qmi_wwan_state)));	/* set up initial state */	info->control = intf;	info->data = intf;	/* and a number of CDC descriptors */	while (len > 3) {		struct usb_descriptor_header *h = (void *)buf;		/* ignore any misplaced descriptors */		if (h->bDescriptorType != USB_DT_CS_INTERFACE)			goto next_desc;		/* buf[2] is CDC descriptor subtype */		switch (buf[2]) {		case USB_CDC_HEADER_TYPE:			if (found & 1 << USB_CDC_HEADER_TYPE) {				dev_dbg(&intf->dev, "extra CDC header/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_header_desc)) {				dev_dbg(&intf->dev, "CDC header len %u/n",					h->bLength);				goto err;			}			break;		case USB_CDC_UNION_TYPE:			if (found & 1 << USB_CDC_UNION_TYPE) {				dev_dbg(&intf->dev, "extra CDC union/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_union_desc)) {				dev_dbg(&intf->dev, "CDC union len %u/n",					h->bLength);				goto err;			}			cdc_union = (struct usb_cdc_union_desc *)buf;			break;		case USB_CDC_ETHERNET_TYPE:			if (found & 1 << USB_CDC_ETHERNET_TYPE) {				dev_dbg(&intf->dev, "extra CDC ether/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {				dev_dbg(&intf->dev, "CDC ether len %u/n",					h->bLength);				goto err;			}			cdc_ether = (struct usb_cdc_ether_desc *)buf;			break;		}		/* Remember which CDC functional descriptors we've seen.  Works		 * for all types we care about, of which USB_CDC_ETHERNET_TYPE		 * (0x0f) is the highest numbered		 */		if (buf[2] < 32)			found |= 1 << buf[2];next_desc:		len -= h->bLength;		buf += h->bLength;	}	/* Use separate control and data interfaces if we found a CDC Union */	if (cdc_union) {		info->data = usb_ifnum_to_if(dev->udev,					     cdc_union->bSlaveInterface0);		if (desc->bInterfaceNumber != cdc_union->bMasterInterface0 ||		    !info->data) {			dev_err(&intf->dev,				"bogus CDC Union: master=%u, slave=%u/n",				cdc_union->bMasterInterface0,				cdc_union->bSlaveInterface0);			goto err;		}	}	/* errors aren't fatal - we can live with the dynamic address */	if (cdc_ether) {		dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);		usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);	}	/* claim data interface and set it up */	if (info->control != info->data) {//.........这里部分代码省略.........

int usbsvn_probe(struct usb_interface *intf, const struct usb_device_id *id){	const struct usb_cdc_union_desc *union_header = NULL;	const struct usb_host_interface *data_desc;	static struct usbsvn *svn;	struct usb_interface *data_intf;	struct usb_device *usbdev = interface_to_usbdev(intf);	u8 *data = intf->altsetting->extra;	int len = intf->altsetting->extralen;	int dev_id;	int err;	if (!share_svn) {		printk(KERN_ERR "%s: netdev not registed/n", __func__);		return -EINVAL;	}	svn = share_svn;	if (!len) {		if (intf->cur_altsetting->endpoint->extralen &&				intf->cur_altsetting->endpoint->extra) {			dev_dbg(&intf->dev,				"Seeking extra descriptors on endpoint/n");			len = intf->cur_altsetting->endpoint->extralen;			data = intf->cur_altsetting->endpoint->extra;		} else {			dev_err(&intf->dev,				"Zero length descriptor references/n");			return -EINVAL;		}	}	while (len > 0) {		/* bDescriptorType */		if (data[1] == USB_DT_CS_INTERFACE) {			/* bDescriptorSubType */			switch (data[2]) {			case USB_CDC_UNION_TYPE:				if (union_header)					break;				union_header =					(struct usb_cdc_union_desc *)data;				break;			default:				break;			}		}		data += data[0];		len -= data[0];	}	if (!union_header) {		dev_err(&intf->dev, "USB CDC isn't union type/n");		return -EINVAL;	}	data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);	if (!data_intf)		return -ENODEV;	data_desc = data_intf->altsetting;	/* To detect usb device order probed */	dev_id = intf->altsetting->desc.bInterfaceNumber / 2;	if (dev_id >= USBSVN_DEVNUM_MAX) {		dev_err(&intf->dev, "Device id %d cannot support/n", dev_id);		return -EINVAL;	}	printk(KERN_ERR "%s: probe dev_id=%d/n", __func__, dev_id);	if (dev_id > 0)		goto skip_netdev;	svn->usbdev = usbdev;	svn->driver_info = (unsigned long)id->driver_info;	/* FIXME: Does need this indeed? */	usbdev->autosuspend_delay = msecs_to_jiffies(200);      /* 200ms */	if (!svn->driver_info) {		schedule_delayed_work(&svn->pm_runtime_work,			msecs_to_jiffies(10000));	}	svn->usbsvn_connected = 1;	svn->flow_suspend = 0;skip_netdev:	if (!svn->driver_info) {		svn = share_svn;		if (!svn) {			dev_err(&intf->dev,			"svnet device doesn't be allocated/n");			err = ENOMEM;			goto out;		}	}	usb_get_dev(usbdev);//.........这里部分代码省略.........

//.........这里部分代码省略.........	init_usb_anchor(&data->tx_anchor);	init_usb_anchor(&data->intr_anchor);	init_usb_anchor(&data->bulk_anchor);	init_usb_anchor(&data->isoc_anchor);	init_usb_anchor(&data->deferred);	hdev = hci_alloc_dev();	if (!hdev) {		kfree(data);		return -ENOMEM;	}	hdev->bus = HCI_USB;	hdev->driver_data = data;	data->hdev = hdev;	SET_HCIDEV_DEV(hdev, &intf->dev);	hdev->open     = btusb_open;	hdev->close    = btusb_close;	hdev->flush    = btusb_flush;	hdev->send     = btusb_send_frame;	hdev->destruct = btusb_destruct;	hdev->notify   = btusb_notify;	hdev->owner = THIS_MODULE;	if (id->driver_info & BTUSB_INTEL_BOOT)		set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);	/* Interface numbers are hardcoded in the specification */	data->isoc = usb_ifnum_to_if(data->udev, 1);	if (!reset)		set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {		if (!disable_scofix)			set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);	}	if (id->driver_info & BTUSB_BROKEN_ISOC)		data->isoc = NULL;	if (id->driver_info & BTUSB_DIGIANSWER) {		data->cmdreq_type = USB_TYPE_VENDOR;		set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	}	if (id->driver_info & BTUSB_CSR) {		struct usb_device *udev = data->udev;		/* Old firmware would otherwise execute USB reset */		if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)			set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);	}	if (id->driver_info & BTUSB_SNIFFER) {		struct usb_device *udev = data->udev;		/* New sniffer firmware has crippled HCI interface */		if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)			set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);

static int qmi_wwan_bind(struct usbnet *dev, struct usb_interface *intf){	int status = -1;	u8 *buf = intf->cur_altsetting->extra;	int len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor *desc = &intf->cur_altsetting->desc;	struct usb_cdc_union_desc *cdc_union = NULL;	struct usb_cdc_ether_desc *cdc_ether = NULL;	u32 found = 0;	struct usb_driver *driver = driver_of(intf);	struct qmi_wwan_state *info = (void *)&dev->data;	BUILD_BUG_ON((sizeof(((struct usbnet *)0)->data) < sizeof(struct qmi_wwan_state)));	/* require a single interrupt status endpoint for subdriver */	if (intf->cur_altsetting->desc.bNumEndpoints != 1)		goto err;	while (len > 3) {		struct usb_descriptor_header *h = (void *)buf;		/* ignore any misplaced descriptors */		if (h->bDescriptorType != USB_DT_CS_INTERFACE)			goto next_desc;		/* buf[2] is CDC descriptor subtype */		switch (buf[2]) {		case USB_CDC_HEADER_TYPE:			if (found & 1 << USB_CDC_HEADER_TYPE) {				dev_dbg(&intf->dev, "extra CDC header/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_header_desc)) {				dev_dbg(&intf->dev, "CDC header len %u/n", h->bLength);				goto err;			}			break;		case USB_CDC_UNION_TYPE:			if (found & 1 << USB_CDC_UNION_TYPE) {				dev_dbg(&intf->dev, "extra CDC union/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_union_desc)) {				dev_dbg(&intf->dev, "CDC union len %u/n", h->bLength);				goto err;			}			cdc_union = (struct usb_cdc_union_desc *)buf;			break;		case USB_CDC_ETHERNET_TYPE:			if (found & 1 << USB_CDC_ETHERNET_TYPE) {				dev_dbg(&intf->dev, "extra CDC ether/n");				goto err;			}			if (h->bLength != sizeof(struct usb_cdc_ether_desc)) {				dev_dbg(&intf->dev, "CDC ether len %u/n",  h->bLength);				goto err;			}			cdc_ether = (struct usb_cdc_ether_desc *)buf;			break;		}		/*		 * Remember which CDC functional descriptors we've seen.  Works		 * for all types we care about, of which USB_CDC_ETHERNET_TYPE		 * (0x0f) is the highest numbered		 */		if (buf[2] < 32)			found |= 1 << buf[2];next_desc:		len -= h->bLength;		buf += h->bLength;	}	/* did we find all the required ones? */	if (!(found & (1 << USB_CDC_HEADER_TYPE)) ||	    !(found & (1 << USB_CDC_UNION_TYPE))) {		dev_err(&intf->dev, "CDC functional descriptors missing/n");		goto err;	}	/* verify CDC Union */	if (desc->bInterfaceNumber != cdc_union->bMasterInterface0) {		dev_err(&intf->dev, "bogus CDC Union: master=%u/n", cdc_union->bMasterInterface0);		goto err;	}	/* need to save these for unbind */	info->control = intf;	info->data = usb_ifnum_to_if(dev->udev,	cdc_union->bSlaveInterface0);	if (!info->data) {		dev_err(&intf->dev, "bogus CDC Union: slave=%u/n", cdc_union->bSlaveInterface0);		goto err;	}	/* errors aren't fatal - we can live with the dynamic address */	if (cdc_ether) {		dev->hard_mtu = le16_to_cpu(cdc_ether->wMaxSegmentSize);		usbnet_get_ethernet_addr(dev, cdc_ether->iMACAddress);	}//.........这里部分代码省略.........

int usbpn_probe(struct usb_interface *intf, const struct usb_device_id *id){	static const char ifname[] = "usbpn%d";	const struct usb_cdc_union_desc *union_header = NULL;	const struct usb_cdc_header_desc *phonet_header = NULL;	const struct usb_host_interface *data_desc;	struct usb_interface *data_intf;	struct usb_device *usbdev = interface_to_usbdev(intf);	struct net_device *dev;	struct usbpn_dev *pnd;	u8 *data;	int len, err;	data = intf->altsetting->extra;	len = intf->altsetting->extralen;	while (len >= 3) {		u8 dlen = data[0];		if (dlen < 3)			return -EINVAL;		/* bDescriptorType */		if (data[1] == USB_DT_CS_INTERFACE) {			/* bDescriptorSubType */			switch (data[2]) {			case USB_CDC_UNION_TYPE:				if (union_header || dlen < 5)					break;				union_header =					(struct usb_cdc_union_desc *)data;				break;			case 0xAB:				if (phonet_header || dlen < 5)					break;				phonet_header =					(struct usb_cdc_header_desc *)data;				break;			}		}		data += dlen;		len -= dlen;	}	if (!union_header || !phonet_header)		return -EINVAL;	data_intf = usb_ifnum_to_if(usbdev, union_header->bSlaveInterface0);	if (data_intf == NULL)		return -ENODEV;	/* Data interface has one inactive and one active setting */	if (data_intf->num_altsetting != 2)		return -EINVAL;	if (data_intf->altsetting[0].desc.bNumEndpoints == 0 &&	    data_intf->altsetting[1].desc.bNumEndpoints == 2)		data_desc = data_intf->altsetting + 1;	else	if (data_intf->altsetting[0].desc.bNumEndpoints == 2 &&	    data_intf->altsetting[1].desc.bNumEndpoints == 0)		data_desc = data_intf->altsetting;	else		return -EINVAL;	dev = alloc_netdev(sizeof(*pnd) + sizeof(pnd->urbs[0]) * rxq_size,				ifname, usbpn_setup);	if (!dev)		return -ENOMEM;	pnd = netdev_priv(dev);	SET_NETDEV_DEV(dev, &intf->dev);	netif_stop_queue(dev);	pnd->dev = dev;	pnd->usb = usb_get_dev(usbdev);	pnd->intf = intf;	pnd->data_intf = data_intf;	spin_lock_init(&pnd->tx_lock);	spin_lock_init(&pnd->rx_lock);	/* Endpoints */	if (usb_pipein(data_desc->endpoint[0].desc.bEndpointAddress)) {		pnd->rx_pipe = usb_rcvbulkpipe(usbdev,			data_desc->endpoint[0].desc.bEndpointAddress);		pnd->tx_pipe = usb_sndbulkpipe(usbdev,			data_desc->endpoint[1].desc.bEndpointAddress);	} else {		pnd->rx_pipe = usb_rcvbulkpipe(usbdev,			data_desc->endpoint[1].desc.bEndpointAddress);		pnd->tx_pipe = usb_sndbulkpipe(usbdev,			data_desc->endpoint[0].desc.bEndpointAddress);	}	pnd->active_setting = data_desc - data_intf->altsetting;	err = usb_driver_claim_interface(&usbpn_driver, data_intf, pnd);	if (err)		goto out;	/* Force inactive mode until the network device is brought UP */	usb_set_interface(usbdev, union_header->bSlaveInterface0,				!pnd->active_setting);	usb_set_intfdata(intf, pnd);	err = register_netdev(dev);//.........这里部分代码省略.........

/* * probes control interface, claims data interface, collects the bulk * endpoints, activates data interface (if needed), maybe sets MTU. * all pure cdc, except for certain firmware workarounds, and knowing * that rndis uses one different rule. */int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf){	u8				*buf = intf->cur_altsetting->extra;	int				len = intf->cur_altsetting->extralen;	struct usb_interface_descriptor	*d;	struct cdc_state		*info = (void *) &dev->data;	int				status;	int				rndis;	struct usb_driver		*driver = driver_of(intf);	if (sizeof dev->data < sizeof *info)		return -EDOM;	/* expect strict spec conformance for the descriptors, but	 * cope with firmware which stores them in the wrong place	 */	if (len == 0 && dev->udev->actconfig->extralen) {		/* Motorola SB4100 (and others: Brad Hards says it's		 * from a Broadcom design) put CDC descriptors here		 */		buf = dev->udev->actconfig->extra;		len = dev->udev->actconfig->extralen;		if (len)			dev_dbg(&intf->dev,				"CDC descriptors on config/n");	}	/* this assumes that if there's a non-RNDIS vendor variant	 * of cdc-acm, it'll fail RNDIS requests cleanly.	 */	rndis = (intf->cur_altsetting->desc.bInterfaceProtocol == 0xff);	memset(info, 0, sizeof *info);	info->control = intf;	while (len > 3) {		if (buf [1] != USB_DT_CS_INTERFACE)			goto next_desc;		/* use bDescriptorSubType to identify the CDC descriptors.		 * We expect devices with CDC header and union descriptors.		 * For CDC Ethernet we need the ethernet descriptor.		 * For RNDIS, ignore two (pointless) CDC modem descriptors		 * in favor of a complicated OID-based RPC scheme doing what		 * CDC Ethernet achieves with a simple descriptor.		 */		switch (buf [2]) {		case USB_CDC_HEADER_TYPE:			if (info->header) {				dev_dbg(&intf->dev, "extra CDC header/n");				goto bad_desc;			}			info->header = (void *) buf;			if (info->header->bLength != sizeof *info->header) {				dev_dbg(&intf->dev, "CDC header len %u/n",					info->header->bLength);				goto bad_desc;			}			break;		case USB_CDC_UNION_TYPE:			if (info->u) {				dev_dbg(&intf->dev, "extra CDC union/n");				goto bad_desc;			}			info->u = (void *) buf;			if (info->u->bLength != sizeof *info->u) {				dev_dbg(&intf->dev, "CDC union len %u/n",					info->u->bLength);				goto bad_desc;			}			/* we need a master/control interface (what we're			 * probed with) and a slave/data interface; union			 * descriptors sort this all out.			 */			info->control = usb_ifnum_to_if(dev->udev,						info->u->bMasterInterface0);			info->data = usb_ifnum_to_if(dev->udev,						info->u->bSlaveInterface0);			if (!info->control || !info->data) {				dev_dbg(&intf->dev,					"master #%u/%p slave #%u/%p/n",					info->u->bMasterInterface0,					info->control,					info->u->bSlaveInterface0,					info->data);				goto bad_desc;			}			if (info->control != intf) {				dev_dbg(&intf->dev, "bogus CDC Union/n");				/* Ambit USB Cable Modem (and maybe others)				 * interchanges master and slave interface.				 */				if (info->data == intf) {					info->data = info->control;//.........这里部分代码省略.........