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

static int chaoskey_open(struct inode *inode, struct file *file){	struct chaoskey *dev;	struct usb_interface *interface;	/* get the interface from minor number and driver information */	interface = usb_find_interface(&chaoskey_driver, iminor(inode));	if (!interface)		return -ENODEV;	usb_dbg(interface, "open");	dev = usb_get_intfdata(interface);	if (!dev) {		usb_dbg(interface, "open (dev)");		return -ENODEV;	}	file->private_data = dev;	mutex_lock(&dev->lock);	++dev->open;	mutex_unlock(&dev->lock);	usb_dbg(interface, "open success");	return 0;}

struct usb_dev_handle* Bench_Open(WORD vid, WORD pid, INT interfaceNumber, INT altInterfaceNumber, struct usb_device** deviceForHandle){    struct usb_bus* bus;    struct usb_device* dev;    struct usb_dev_handle* udev;    for (bus = usb_get_busses(); bus; bus = bus->next)    {        for (dev = bus->devices; dev; dev = dev->next)        {            if (dev->descriptor.idVendor == vid && dev->descriptor.idProduct == pid)            {				if ((udev = usb_open(dev)))				{					if (dev->descriptor.bNumConfigurations)					{						if (usb_find_interface(&dev->config[0], interfaceNumber, altInterfaceNumber, NULL) != NULL)						{							if (deviceForHandle) *deviceForHandle = dev;							return udev;						}					}					usb_close(udev);				}            }        }    }    return NULL;}

static int skel_open(struct inode *inode, struct file *file){	struct usb_skel *dev;	struct usb_interface *interface;	int subminor;	int retval = 0;	subminor = iminor(inode);	interface = usb_find_interface(&skel_driver, subminor);	if (!interface) {		err ("%s - error, can't find device for minor %d",		     __FUNCTION__, subminor);		retval = -ENODEV;		goto exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto exit;	}		/* increment our usage count for the device */	kref_get(&dev->kref);	/* save our object in the file's private structure */	file->private_data = dev;exit:	return retval;}

int wagusb_open(struct inode *inode, struct file *filep){  struct usb_wagusb *dev;  struct usb_interface *interface;  int subminor;  subminor = iminor(inode);  interface = usb_find_interface(&wagusb_driver, subminor);  if (!interface)  {    printk(KERN_ALERT "wagusb: wagusb_open() ERROR: cant find interface/n");    return -ENODEV;  }  dev = usb_get_intfdata(interface);  if (!dev)  {    printk(KERN_ALERT "wagusb: wagusb_open() ERROR: cant find usb_wagusb/n");    return -ENODEV;  }  mutex_lock(&dev->lock);  dev->read_pos = 0;  dev->bytes_read = 0;  filep->private_data = dev;  mutex_unlock(&dev->lock);  return 0;}

static int yurex_open(struct inode *inode, struct file *file){	struct usb_yurex *dev;	struct usb_interface *interface;	int subminor;	int retval = 0;	subminor = iminor(inode);	interface = usb_find_interface(&yurex_driver, subminor);	if (!interface) {		printk(KERN_ERR "%s - error, can't find device for minor %d",		       __func__, subminor);		retval = -ENODEV;		goto exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto exit;	}	/* increment our usage count for the device */	kref_get(&dev->kref);	/* save our object in the file's private structure */	mutex_lock(&dev->io_mutex);	file->private_data = dev;	mutex_unlock(&dev->io_mutex);exit:	return retval;}

/* Char device operations */static int temper_open(struct inode *inode, struct file *file){	struct usb_interface *intf;	struct usb_temper *temper_dev;	int minor;	minor = iminor(inode);	/* Get interface with minor */	intf = usb_find_interface(&temper_driver, minor);	if (!intf) {		printk(KERN_WARNING "temper: cannot find USB interface/n");		return -ENODEV;	}	/* Get private data from interface */	temper_dev = usb_get_intfdata (intf);	if (!temper_dev) {		printk (KERN_WARNING "temper: cannot find device for minor %d/n", minor);		return -ENODEV;	}	/* Save the pointer for further use */	file->private_data = (void *)temper_dev;	return 0;}

//// char device functions//static int dragon_usb_open (struct inode *inode, struct file *file){  struct usb_dragon_usb *dev;  struct usb_interface *interface;  int minor;    minor = iminor(inode);  // Get interface for device  interface = usb_find_interface (&dragon_usb_driver, minor);  if (!interface)    return -ENODEV;  // Get private data from interface  dev = usb_get_intfdata (interface);  if (dev == NULL) {      printk (KERN_WARNING "dragon_usb_open(): can't find device for minor %d/n", minor);      return -ENODEV;  }  // Set to file structure  file->private_data = (void *)dev;  return 0;}

int lighty_open(struct inode *inode, struct file *filp){    struct usb_lighty *dev;    struct usb_interface *interface;    int subminor;    //get the minor number from the inode    subminor = iminor(inode);    //use the minor number to get the assocaited interface    interface = usb_find_interface(&lighty_driver, subminor);    //make sure interface was found    if (!interface) {        printk (KERN_NOTICE "%s - error, can't find device for minor %d",  __FUNCTION__,                                                                    subminor);        return -ENODEV;    }    //get our data structure that was saved in the device interface in probe()    dev = usb_get_intfdata(interface);    if (!dev) {	printk (KERN_NOTICE "Could not get interface data/n");        return -ENODEV;	}	    //increment our device reference counter    kref_get(&dev->refcount);    //save our device struct (pointer) in the file's private data structure    filp->private_data = dev;    //return success    return 0;}

static int usblp_open(struct inode *inode, struct file *file){	int minor = iminor(inode);	struct usblp *usblp;	struct usb_interface *intf;	int retval;        unsigned long arg = NULL; // Added by PaN. Modified by Jiahao        long ioctl_retval;        // Added by Jiahao	if (minor < 0)		return -ENODEV;	mutex_lock(&usblp_mutex);	retval = -ENODEV;	intf = usb_find_interface(&usblp_driver, minor);	if (!intf)		goto out;	usblp = usb_get_intfdata(intf);	if (!usblp || !usblp->dev || !usblp->present)		goto out;	retval = -EBUSY;	if (usblp->used)		goto out;	/*	 * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:	 *  - We do not want persistent state which close(2) does not clear	 *  - It is not used anyway, according to CUPS people	 */	retval = usb_autopm_get_interface(intf);	if (retval < 0)		goto out;	usblp->used = 1;	file->private_data = usblp;	usblp->wcomplete = 1; /* we begin writeable */	usblp->wstatus = 0;	usblp->rcomplete = 0;	if (handle_bidir(usblp) < 0) {		usb_autopm_put_interface(intf);		usblp->used = 0;		file->private_data = NULL;		retval = -EIO;	}        /* Added by PaN */        if ((ioctl_retval=usblp_ioctl(file, LPGETID, arg)) <0)  // modified by Jiahao        {                // Update device id failed        }out:	mutex_unlock(&usblp_mutex);	return retval;}

static int skel_open(struct inode *inode, struct file *file){	struct usb_skel *dev;	struct usb_interface *interface;	int subminor;	int retval = 0;	printk(KERN_INFO "eric_open/n");	subminor = iminor(inode);	interface = usb_find_interface(&skel_driver, subminor);	if (!interface) {		err("%s - error, can't find device for minor %d",		     __func__, subminor);		retval = -ENODEV;		goto exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto exit;	}	/* increment our usage count for the device */	kref_get(&dev->kref);	/* lock the device to allow correctly handling errors	 * in resumption */	mutex_lock(&dev->io_mutex);	if (!dev->open_count++) {		retval = usb_autopm_get_interface(interface);			if (retval) {				dev->open_count--;				mutex_unlock(&dev->io_mutex);				kref_put(&dev->kref, skel_delete);				goto exit;			}	} /* else { //uncomment this block if you want exclusive open		retval = -EBUSY;		dev->open_count--;		mutex_unlock(&dev->io_mutex);		kref_put(&dev->kref, skel_delete);		goto exit;	} */	/* prevent the device from being autosuspended */	/* save our object in the file's private structure */	file->private_data = dev;	mutex_unlock(&dev->io_mutex);exit:	return retval;}

/** *	iowarrior_open */static int iowarrior_open(struct inode *inode, struct file *file){	struct iowarrior *dev = NULL;	struct usb_interface *interface;	int subminor;	int retval = 0;	dbg("%s", __func__);	mutex_lock(&iowarrior_mutex);	subminor = iminor(inode);	interface = usb_find_interface(&iowarrior_driver, subminor);	if (!interface) {		mutex_unlock(&iowarrior_mutex);		err("%s - error, can't find device for minor %d", __func__,		    subminor);		return -ENODEV;	}	mutex_lock(&iowarrior_open_disc_lock);	dev = usb_get_intfdata(interface);	if (!dev) {		mutex_unlock(&iowarrior_open_disc_lock);		mutex_unlock(&iowarrior_mutex);		return -ENODEV;	}	mutex_lock(&dev->mutex);	mutex_unlock(&iowarrior_open_disc_lock);	/* Only one process can open each device, no sharing. */	if (dev->opened) {		retval = -EBUSY;		goto out;	}	/* setup interrupt handler for receiving values */	if ((retval = usb_submit_urb(dev->int_in_urb, GFP_KERNEL)) < 0) {		dev_err(&interface->dev, "Error %d while submitting URB/n", retval);		retval = -EFAULT;		goto out;	}	/* increment our usage count for the driver */	++dev->opened;	/* save our object in the file's private structure */	file->private_data = dev;	retval = 0;out:	mutex_unlock(&dev->mutex);	mutex_unlock(&iowarrior_mutex);	return retval;}

static int iowarrior_open(struct inode *inode, struct file *file){	struct iowarrior *dev = NULL;	struct usb_interface *interface;	int subminor;	int retval = 0;	dbg("%s", __func__);	mutex_lock(&iowarrior_mutex);	subminor = iminor(inode);	interface = usb_find_interface(&iowarrior_driver, subminor);	if (!interface) {		mutex_unlock(&iowarrior_mutex);		err("%s - error, can't find device for minor %d", __func__,		    subminor);		return -ENODEV;	}	mutex_lock(&iowarrior_open_disc_lock);	dev = usb_get_intfdata(interface);	if (!dev) {		mutex_unlock(&iowarrior_open_disc_lock);		mutex_unlock(&iowarrior_mutex);		return -ENODEV;	}	mutex_lock(&dev->mutex);	mutex_unlock(&iowarrior_open_disc_lock);	/*                                                    */	if (dev->opened) {		retval = -EBUSY;		goto out;	}	/*                                              */	if ((retval = usb_submit_urb(dev->int_in_urb, GFP_KERNEL)) < 0) {		dev_err(&interface->dev, "Error %d while submitting URB/n", retval);		retval = -EFAULT;		goto out;	}	/*                                          */	++dev->opened;	/*                                                 */	file->private_data = dev;	retval = 0;out:	mutex_unlock(&dev->mutex);	mutex_unlock(&iowarrior_mutex);	return retval;}

static int usblp_open(struct inode *inode, struct file *file){	int minor = iminor(inode);	struct usblp *usblp;	struct usb_interface *intf;	int retval;	if (minor < 0)		return -ENODEV;	mutex_lock (&usblp_mutex);	retval = -ENODEV;	intf = usb_find_interface(&usblp_driver, minor);	if (!intf) {		goto out;	}	usblp = usb_get_intfdata (intf);	if (!usblp || !usblp->dev || !usblp->present)		goto out;	retval = -EBUSY;	if (usblp->used)		goto out;	/*	 * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:	 *  - We do not want persistent state which close(2) does not clear	 *  - It is not used anyway, according to CUPS people	 */	retval = usb_autopm_get_interface(intf);	if (retval < 0)		goto out;	usblp->used = 1;	file->private_data = usblp;	usblp->wcomplete = 1; /* we begin writeable */	usblp->wstatus = 0;	usblp->rcomplete = 0;	if (handle_bidir(usblp) < 0) {		usb_autopm_put_interface(intf);		usblp->used = 0;		file->private_data = NULL;		retval = -EIO;	}out:	mutex_unlock (&usblp_mutex);	return retval;}

static int pixcir_open (struct inode *inode, struct file *file){	struct pixcir_mt_usb *dev;	struct usb_interface *interface;	int subminor;	char *buf,*getbuf;	int retval;		buf = NULL;	getbuf = NULL;	retval=0;		subminor = iminor(inode);		//printk("enter pixcir_open function/n");		interface = usb_find_interface(&pixcir_driver, subminor);	if (!interface) {		err("%s - error, can't find device for minor %d",		     __func__, subminor);		retval = -ENODEV;		return retval;		}		dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		return retval;	}		dev->udev = usb_get_dev(interface_to_usbdev(interface));	dev->interface = interface;	kref_get(&dev->kref);	mutex_lock(&dev->io_mutex);	if (!dev->open_count++) {		retval = usb_autopm_get_interface(interface);			if (retval) {				dev->open_count--;				mutex_unlock(&dev->io_mutex);				kref_put(&dev->kref, pixcir_delete);				return retval;			}	}	/* save our object in the file's private structure */	file->private_data = dev;	mutex_unlock(&dev->io_mutex);		return 0;}

static int piusb_open(struct inode *inode, struct file *file){	struct device_extension *pdx = NULL;	struct usb_interface *interface;	int subminor;	int retval = 0;	dbg("Piusb_Open()");	subminor = iminor(inode);	interface = usb_find_interface(&piusb_driver, subminor);	if (!interface) {		printk(KERN_ERR "%s - error, can't find device for minor %d/n",		       __func__, subminor);		retval = -ENODEV;		goto exit_no_device;	}	pdx = usb_get_intfdata(interface);	if (!pdx) {		retval = -ENODEV;		goto exit_no_device;	}	dbg("Alternate Setting = %d", interface->num_altsetting);	pdx->bulk_in_size_returned = 0;	pdx->bulk_in_byte_trk = 0;	pdx->PixelUrb = NULL;	pdx->frameIdx = 0;	pdx->urbIdx = 0;	pdx->maplist_numPagesMapped = NULL;	pdx->userBufMapped = 0;	pdx->sgl = NULL;	pdx->sgEntries = NULL;	pdx->gotPixelData = 0;	pdx->pendingWrite = 0;	pdx->pendedPixelUrbs = NULL;	pdx->num_frames = 0;	pdx->active_frame = 0;	pdx->frameSize = 0;	/* increment our usage count for the device */	kref_get(&pdx->kref);	/* save our object in the file's private structure */	file->private_data = pdx;exit_no_device:	return retval;}

/** * fx2_bulk_open - Does nothing in this case * * @node: not used * @fp: Used to store private structure * * Returns 0 on success */static int fx2_bulk_open(struct inode *node, struct file *fp){	int subminor;	struct usb_interface *intf;	struct osr_usb_fx2_dev *dev_priv = NULL;	subminor = iminor(node);	intf = usb_find_interface(&osr_usb_fx2_driver, subminor);	if (!intf) {		printk("fx2_bulk_open: Cannot find USB Interface/n");		return -ENODEV;	}	dev_priv = usb_get_intfdata(intf);	if (!dev_priv) {		printk("fx2_bulk_open: Cannot find device private structure/n");		return -ENODEV;	}	fp->private_data = dev_priv;	switch (dev_priv->udev->speed) {	case USB_SPEED_HIGH:		dev_priv->bulk_buffer_size = BULK_HIGH_SPEED_SIZE;		break;	case USB_SPEED_FULL:		dev_priv->bulk_buffer_size = BULK_FULL_SPEED_SIZE;		break;	default:		printk("fx2_bulk_open: Unsupported speed/n");		return -EINVAL;	}	/* Allocate bulk buffer */	if (!dev_priv->bulk_buffer) {		printk("fx2_bulk_open: Allocate %ld bytes/n",			dev_priv->bulk_buffer_size);		dev_priv->bulk_buffer = kmalloc(dev_priv->bulk_buffer_size,						GFP_KERNEL);	}	return 0;}

static int lcd_open(struct inode *inode, struct file *file){	struct usb_lcd *dev;	struct usb_interface *interface;	int subminor, r;	mutex_lock(&lcd_mutex);	subminor = iminor(inode);	interface = usb_find_interface(&lcd_driver, subminor);	if (!interface) {		mutex_unlock(&lcd_mutex);		printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d/n",		       __func__, subminor);		return -ENODEV;	}	mutex_lock(&open_disc_mutex);	dev = usb_get_intfdata(interface);	if (!dev) {		mutex_unlock(&open_disc_mutex);		mutex_unlock(&lcd_mutex);		return -ENODEV;	}	/* increment our usage count for the device */	kref_get(&dev->kref);	mutex_unlock(&open_disc_mutex);	/* grab a power reference */	r = usb_autopm_get_interface(interface);	if (r < 0) {		kref_put(&dev->kref, lcd_delete);		mutex_unlock(&lcd_mutex);		return r;	}	/* save our object in the file's private structure */	file->private_data = dev;	mutex_unlock(&lcd_mutex);	return 0;}

static int vstusb_open(struct inode *inode, struct file *file){	struct vstusb_device *vstdev;	struct usb_interface *interface;	interface = usb_find_interface(&vstusb_driver, iminor(inode));	if (!interface) {		printk(KERN_ERR KBUILD_MODNAME		       ": %s - error, can't find device for minor %d/n",		       __func__, iminor(inode));		return -ENODEV;	}	vstdev = usb_get_intfdata(interface);	if (!vstdev)		return -ENODEV;	/* lock this device */	mutex_lock(&vstdev->lock);	/* can only open one time */	if ((!vstdev->present) || (vstdev->isopen)) {		mutex_unlock(&vstdev->lock);		return -EBUSY;	}	/* increment our usage count */	kref_get(&vstdev->kref);	vstdev->isopen = 1;	/* save device in the file's private structure */	file->private_data = vstdev;	dev_dbg(&vstdev->usb_dev->dev, "%s: opened/n", __func__);	mutex_unlock(&vstdev->lock);	return 0;}

static int usbtmc_open(struct inode *inode, struct file *filp){	struct usb_interface *intf;	struct usbtmc_device_data *data;	int retval = 0;	intf = usb_find_interface(&usbtmc_driver, iminor(inode));	if (!intf) {		pr_err("can not find device for minor %d", iminor(inode));		return -ENODEV;	}	data = usb_get_intfdata(intf);	kref_get(&data->kref);	/* Store pointer in file structure's private data field */	filp->private_data = data;	return retval;}

static int synccom_open(struct inode *inode, struct file *file){        	struct synccom_port *port;	struct usb_interface *interface;	int subminor;	int retval = 0;	subminor = iminor(inode);	interface = usb_find_interface(&synccom_driver, subminor);	if (!interface) {		pr_err("%s - error, can't find device for minor %d/n",			__func__, subminor);		retval = -ENODEV;		goto exit;	}	port = usb_get_intfdata(interface);	if (!port) {		retval = -ENODEV;		goto exit;	}	retval = usb_autopm_get_interface(interface);	if (retval)		goto exit;           	/* increment our usage count for the device */	kref_get(&port->kref);	/* save our object in the file's private structure */	file->private_data = port;	        exit:   	return retval;}

static int diodev_open(struct inode *inode, struct file *file) {  struct usb_dio_dev *dev;  struct usb_interface *interface;  int subminor;  int p;  FUNC_HI();    subminor = iminor(inode);    interface = usb_find_interface(&usb_dio_driver, subminor);  if (!interface) {    printk(KERN_ALERT "%s: Can't find device for minor %d/n", usb_dio_driver.name, subminor);    FUNC_ERR();    return -ENODEV;  }    dev = usb_get_intfdata(interface);  if (!dev) {    printk(KERN_ALERT "%s: Can't find interface data for minor %d/n", usb_dio_driver.name, subminor);    FUNC_ERR();    return -ENODEV;  }    kref_get(&dev->kref);    file->private_data = dev;    if (down_interruptible(&dev->buffer_sem)) {    FUNC_ERR();    return -EINTR;  }  dev->buffer_head = 0;  dev->buffer_tail = 0;  p = down_trylock(&dev->buffer_empty_sem);  up(&dev->buffer_sem);    FUNC_BYE();  return 0;}

static int skel_open(struct inode *inode, struct file *file){	struct usb_skel *dev;	struct usb_interface *interface;	int subminor;	int retval = 0;	subminor = iminor(inode);	interface = usb_find_interface(&skel_driver, subminor);	if (!interface) {		err("%s - error, can't find device for minor %d",		     __func__, subminor);		retval = -ENODEV;		goto exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto exit;	}		kref_get(&dev->kref);	mutex_lock(&dev->io_mutex);	retval = usb_autopm_get_interface(interface);	if (retval)		goto out_err;		file->private_data = dev;	mutex_unlock(&dev->io_mutex);exit:	return retval;}

static int bladerf_open(struct inode *inode, struct file *file){    bladerf_device_t *dev;    struct usb_interface *interface;    int subminor;    subminor = iminor(inode);    interface = usb_find_interface(&bladerf_driver, subminor);    if (interface == NULL) {        pr_err("%s - error, cannot find device for minor %d/n", __func__, subminor);        return -ENODEV;    }    dev = usb_get_intfdata(interface);    if (dev == NULL) {        return -ENODEV;    }    file->private_data = dev;    return 0;}

static int urbtc_open(struct inode *inode, struct file *file){	struct usb_urbtc *dev;	struct usb_interface *interface;	int subminor;	int retval = 0;	subminor = iminor(inode);	interface = usb_find_interface(&urbtc_driver, subminor);	if (!interface) {		/* err ("%s - error, can't find device for minor %d", */		/*      __FUNCTION__, subminor); */		retval = -ENODEV;		goto exit;	}	dev = usb_get_intfdata(interface);	if (!dev) {		retval = -ENODEV;		goto exit;	}	dev->read_status = URBTC_STATUS_READ_REQUEST;	dev->readbuf_enabled = 0;	dev->write_status = URBTC_STATUS_WRITE_DESIRE;	/* increment our usage count for the device */	kref_get(&dev->kref);	/* save our object in the file's private structure */	file->private_data = dev;exit:	return retval;}

/** *	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",		     __func__, 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;}