struct usb_interface

struct usb_interface {/* array of alternate settings for this interface, * stored in no particular order */struct usb_host_interface *altsetting;struct usb_host_interface *cur_altsetting;/* the currently * active alternate setting */unsigned num_altsetting;/* number of alternate settings *//* If there is an interface association descriptor then it will list * the associated interfaces */struct usb_interface_assoc_descriptor *intf_assoc;int minor;/* minor number this interface is * bound to */enum usb_interface_condition condition;/* state of binding */unsigned sysfs_files_created:1;/* the sysfs attributes exist */unsigned ep_devs_created:1;/* endpoint "devices" exist */unsigned unregistering:1;/* unregistration is in progress */unsigned needs_remote_wakeup:1;/* driver requires remote wakeup */unsigned needs_altsetting0:1;/* switch to altsetting 0 is pending */unsigned needs_binding:1;/* needs delayed unbind/rebind */unsigned reset_running:1;unsigned resetting_device:1;/* true: bandwidth alloc after reset */struct device dev;/* interface specific device info */struct device *usb_dev;atomic_t pm_usage_cnt;/* usage counter for autosuspend */struct work_struct reset_ws;/* for resets in atomic context */};/** * struct usb_interface - what usb device drivers talk to * @altsetting: array of interface structures, one for each alternate *setting that may be selected.  Each one includes a set of *endpoint configurations.  They will be in no particular order. * @cur_altsetting: the current altsetting. * @num_altsetting: number of altsettings defined. * @intf_assoc: interface association descriptor * @minor: the minor number assigned to this interface, if this *interface is bound to a driver that uses the USB major number. *If this interface does not use the USB major, this field should *be unused.  The driver should set this value in the probe() *function of the driver, after it has been assigned a minor *number from the USB core by calling usb_register_dev(). * @condition: binding state of the interface: not bound, binding *(in probe()), bound to a driver, or unbinding (in disconnect()) * @sysfs_files_created: sysfs attributes exist * @ep_devs_created: endpoint child pseudo-devices exist * @unregistering: flag set when the interface is being unregistered * @needs_remote_wakeup: flag set when the driver requires remote-wakeup *capability during autosuspend. * @needs_altsetting0: flag set when a set-interface request for altsetting 0 *has been deferred. * @needs_binding: flag set when the driver should be re-probed or unbound *following a reset or suspend operation it doesn't support. * @dev: driver model's view of this device * @usb_dev: if an interface is bound to the USB major, this will point *to the sysfs representation for that device. * @pm_usage_cnt: PM usage counter for this interface * @reset_ws: Used for scheduling resets from atomic context. * @reset_running: set to 1 if the interface is currently running a *      queued reset so that usb_cancel_queued_reset() doesn't try to *      remove from the workqueue when running inside the worker *      thread. See __usb_queue_reset_device(). * @resetting_device: USB core reset the device, so use alt setting 0 as *current; needs bandwidth alloc after reset. * * USB device drivers attach to interfaces on a physical device.  Each * interface encapsulates a single high level function, such as feeding * an audio stream to a speaker or reporting a change in a volume control. * Many USB devices only have one interface.  The protocol used to talk to * an interface's endpoints can be defined in a usb "class" specification, * or by a product's vendor.  The (default) control endpoint is part of * every interface, but is never listed among the interface's descriptors. * * The driver that is bound to the interface can use standard driver model * calls such as dev_get_drvdata() on the dev member of this structure. * * Each interface may have alternate settings.  The initial configuration * of a device sets altsetting 0, but the device driver can change * that setting using usb_set_interface().  Alternate settings are often * used to control the use of periodic endpoints, such as by having * different endpoints use different amounts of reserved USB bandwidth. * All standards-conformant USB devices that use isochronous endpoints * will use them in non-default settings. * * The USB specification says that alternate setting numbers must run from * 0 to one less than the total number of alternate settings.  But some * devices manage to mess this up, and the structures aren't necessarily * stored in numerical order anyhow.  Use usb_altnum_to_altsetting() to * look up an alternate setting in the altsetting array based on its number. */