usb_gadget.h.rej

linux得一些常用命令,以及linux环境下的c编程

+  *
+  * this affects the device status reported by the hardware driver.
+  * some hardware may not support bus-powered operation, in which
+  * case this feature's value can never change.
+  *
+  * returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_clear_selfpowered (struct usb_gadget *gadget)
+ {
+ 	if (!gadget->ops->set_selfpowered)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->set_selfpowered (gadget, 0);
+ }
+ 
+ /**
+  * usb_gadget_vbus_connect - Notify controller that VBUS is powered
+  * @gadget:The device which now has VBUS power.
+  *
+  * This call is used by a driver for an external transceiver (or GPIO)
+  * that detects a VBUS power session starting.  Common responses include
+  * resuming the controller, activating the D+ (or D-) pullup to let the
+  * host detect that a USB device is attached, and starting to draw power
+  * (8mA or possibly more, especially after SET_CONFIGURATION).
+  *
+  * Returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_vbus_connect(struct usb_gadget *gadget)
+ {
+ 	if (!gadget->ops->vbus_session)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->vbus_session (gadget, 1);
+ }
+ 
+ /**
+  * usb_gadget_vbus_draw - constrain controller's VBUS power usage
+  * @gadget:The device whose VBUS usage is being described
+  * @mA:How much current to draw, in milliAmperes.  This should be twice
+  *	the value listed in the configuration descriptor bMaxPower field.
+  *
+  * This call is used by gadget drivers during SET_CONFIGURATION calls,
+  * reporting how much power the device may consume.  For example, this
+  * could affect how quickly batteries are recharged.
+  *
+  * Returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_vbus_draw(struct usb_gadget *gadget, unsigned mA)
+ {
+ 	if (!gadget->ops->vbus_draw)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->vbus_draw (gadget, mA);
+ }
+ 
+ /**
+  * usb_gadget_vbus_disconnect - notify controller about VBUS session end
+  * @gadget:the device whose VBUS supply is being described
+  *
+  * This call is used by a driver for an external transceiver (or GPIO)
+  * that detects a VBUS power session ending.  Common responses include
+  * reversing everything done in usb_gadget_vbus_connect().
+  *
+  * Returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_vbus_disconnect(struct usb_gadget *gadget)
+ {
+ 	if (!gadget->ops->vbus_session)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->vbus_session (gadget, 0);
+ }
+ 
+ /**
+  * usb_gadget_connect - software-controlled connect to USB host
+  * @gadget:the peripheral being connected
+  *
+  * Enables the D+ (or potentially D-) pullup.  The host will start
+  * enumerating this gadget when the pullup is active and a VBUS session
+  * is active (the link is powered).  This pullup is always enabled unless
+  * usb_gadget_disconnect() has been used to disable it.
+  *
+  * Returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_connect (struct usb_gadget *gadget)
+ {
+ 	if (!gadget->ops->pullup)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->pullup (gadget, 1);
+ }
+ 
+ /**
+  * usb_gadget_disconnect - software-controlled disconnect from USB host
+  * @gadget:the peripheral being disconnected
+  *
+  * Disables the D+ (or potentially D-) pullup, which the host may see
+  * as a disconnect (when a VBUS session is active).  Not all systems
+  * support software pullup controls.
+  *
+  * This routine may be used during the gadget driver bind() call to prevent
+  * the peripheral from ever being visible to the USB host, unless later
+  * usb_gadget_connect() is called.  For example, user mode components may
+  * need to be activated before the system can talk to hosts.
+  *
+  * Returns zero on success, else negative errno.
+  */
+ static inline int
+ usb_gadget_disconnect (struct usb_gadget *gadget)
+ {
+ 	if (!gadget->ops->pullup)
+ 		return -EOPNOTSUPP;
+ 	return gadget->ops->pullup (gadget, 0);
+ }
+ 
+ 
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+ /**
+  * struct usb_gadget_driver - driver for usb 'slave' devices
+  * @function: String describing the gadget's function
+  * @speed: Highest speed the driver handles.
+  * @bind: Invoked when the driver is bound to a gadget, usually
+  * 	after registering the driver.
+  * 	At that point, ep0 is fully initialized, and ep_list holds
+  * 	the currently-available endpoints.
+  * 	Called in a context that permits sleeping.
+  * @setup: Invoked for ep0 control requests that aren't handled by
+  * 	the hardware level driver. Most calls must be handled by
+  * 	the gadget driver, including descriptor and configuration
+  * 	management.  The 16 bit members of the setup data are in
+  * 	cpu order. Called in_interrupt; this may not sleep.  Driver
+  *	queues a response to ep0, or returns negative to stall.
+  * @disconnect: Invoked after all transfers have been stopped,
+  * 	when the host is disconnected.  May be called in_interrupt; this
+  * 	may not sleep.  Some devices can't detect disconnect, so this might
+  *	not be called except as part of controller shutdown.
+  * @unbind: Invoked when the driver is unbound from a gadget,
+  * 	usually from rmmod (after a disconnect is reported).
+  * 	Called in a context that permits sleeping.
+  * @suspend: Invoked on USB suspend.  May be called in_interrupt.
+  * @resume: Invoked on USB resume.  May be called in_interrupt.
+  * @driver: Driver model state for this driver.
+  *
+  * Devices are disabled till a gadget driver successfully bind()s, which
+  * means the driver will handle setup() requests needed to enumerate (and
+  * meet "chapter 9" requirements) then do some useful work.
+  *
+  * If gadget->is_otg is true, the gadget driver must provide an OTG
+  * descriptor during enumeration, or else fail the bind() call.  In such
+  * cases, no USB traffic may flow until both bind() returns without
+  * having called usb_gadget_disconnect(), and the USB host stack has
+  * initialized.
+  *
+  * Drivers use hardware-specific knowledge to configure the usb hardware.
+  * endpoint addressing is only one of several hardware characteristics that
+  * are in descriptors the ep0 implementation returns from setup() calls.
+  *
+  * Except for ep0 implementation, most driver code shouldn't need change to
+  * run on top of different usb controllers.  It'll use endpoints set up by
+  * that ep0 implementation.
+  *
+  * The usb controller driver handles a few standard usb requests.  Those
+  * include set_address, and feature flags for devices, interfaces, and
+  * endpoints (the get_status, set_feature, and clear_feature requests).
+  *
+  * Accordingly, the driver's setup() callback must always implement all
+  * get_descriptor requests, returning at least a device descriptor and
+  * a configuration descriptor.  Drivers must make sure the endpoint
+  * descriptors match any hardware constraints. Some hardware also constrains
+  * other descriptors. (The pxa250 allows only configurations 1, 2, or 3).
+  *
+  * The driver's setup() callback must also implement set_configuration,
+  * and should also implement set_interface, get_configuration, and
+  * get_interface.  Setting a configuration (or interface) is where
+  * endpoints should be activated or (config 0) shut down.
+  *
+  * (Note that only the default control endpoint is supported.  Neither
+  * hosts nor devices generally support control traffic except to ep0.)
+  *
+  * Most devices will ignore USB suspend/resume operations, and so will
+  * not provide those callbacks.  However, some may need to change modes
+  * when the host is not longer directing those activities.  For example,
+  * local controls (buttons, dials, etc) may need to be re-enabled since
+  * the (remote) host can't do that any longer; or an error state might
+  * be cleared, to make the device behave identically whether or not
+  * power is maintained.
+  */
+ struct usb_gadget_driver {
+ 	char			*function;
+ 	enum usb_device_speed	speed;
+ 	int			(*bind)(struct usb_gadget *);
+ 	void			(*unbind)(struct usb_gadget *);
+ 	int			(*setup)(struct usb_gadget *,
+ 					const struct usb_ctrlrequest *);
+ 	void			(*disconnect)(struct usb_gadget *);
+ 	void			(*suspend)(struct usb_gadget *);
+ 	void			(*resume)(struct usb_gadget *);
+ 
+ 	// FIXME support safe rmmod
+ 	struct device_driver	driver;
+ };
+ 
+ 
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+ /* driver modules register and unregister, as usual.
+  * these calls must be made in a context that can sleep.
+  *
+  * these will usually be implemented directly by the hardware-dependent
+  * usb bus interface driver, which will only support a single driver.
+  */
+ 
+ /**
+  * usb_gadget_register_driver - register a gadget driver
+  * @driver:the driver being registered
+  *
+  * Call this in your gadget driver's module initialization function,
+  * to tell the underlying usb controller driver about your driver.
+  * The driver's bind() function will be called to bind it to a
+  * gadget.  This function must be called in a context that can sleep.
+  */
+ int usb_gadget_register_driver (struct usb_gadget_driver *driver);
+ 
+ /**
+  * usb_gadget_unregister_driver - unregister a gadget driver
+  * @driver:the driver being unregistered
+  *
+  * Call this in your gadget driver's module cleanup function,
+  * to tell the underlying usb controller that your driver is
+  * going away.  If the controller is connected to a USB host,
+  * it will first disconnect().  The driver is also requested
+  * to unbind() and clean up any device state, before this procedure
+  * finally returns.
+  * This function must be called in a context that can sleep.
+  */
+ int usb_gadget_unregister_driver (struct usb_gadget_driver *driver);
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+ /* utility to simplify dealing with string descriptors */
+ 
+ /**
+  * struct usb_string - wraps a C string and its USB id
+  * @id:the (nonzero) ID for this string
+  * @s:the string, in UTF-8 encoding
+  *
+  * If you're using usb_gadget_get_string(), use this to wrap a string
+  * together with its ID.
+  */
+ struct usb_string {
+ 	u8			id;
+ 	const char		*s;
+ };
+ 
+ /**
+  * struct usb_gadget_strings - a set of USB strings in a given language
+  * @language:identifies the strings' language (0x0409 for en-us)
+  * @strings:array of strings with their ids
+  *
+  * If you're using usb_gadget_get_string(), use this to wrap all the
+  * strings for a given language.
+  */
+ struct usb_gadget_strings {
+ 	u16			language;	/* 0x0409 for en-us */
+ 	struct usb_string	*strings;
+ };
+ 
+ /* put descriptor for string with that id into buf (buflen >= 256) */
+ int usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf);
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+ /* utility to simplify managing config descriptors */
+ 
+ /* write vector of descriptors into buffer */
+ int usb_descriptor_fillbuf(void *, unsigned,
+ 		const struct usb_descriptor_header **);
+ 
+ /* build config descriptor from single descriptor vector */
+ int usb_gadget_config_buf(const struct usb_config_descriptor *config,
+ 	void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
+ 
+ /*-------------------------------------------------------------------------*/
+ 
+ /* utility wrapping a simple endpoint selection policy */
+ 
+ extern struct usb_ep *usb_ep_autoconfig (struct usb_gadget *,
+ 			struct usb_endpoint_descriptor *) __init;
+ 
+ extern void usb_ep_autoconfig_reset (struct usb_gadget *) __init;
+ 
+ #endif  /* __KERNEL__ */
+ 
+ #endif	/* __LINUX_USB_GADGET_H */