drivers/usb/gadget/function/u_fs.h - third_party/kernel - Git at Google

 /* SPDX-License-Identifier: GPL-2.0 */
 /*
  * u_fs.h
  *
  * Utility definitions for the FunctionFS
  *
  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
  *		http://www.samsung.com
  *
  * Author: Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>
  */

 #ifndef U_FFS_H
 #define U_FFS_H

 #include <linux/usb/composite.h>
 #include <linux/list.h>
 #include <linux/mutex.h>
 #include <linux/workqueue.h>
 #include <linux/refcount.h>

 #ifdef VERBOSE_DEBUG
 #ifndef pr_vdebug
 #  define pr_vdebug pr_debug
 #endif /* pr_vdebug */
 #  define ffs_dump_mem(prefix, ptr, len) \
 	print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
 #else
 #ifndef pr_vdebug
 #  define pr_vdebug(...)                 do { } while (0)
 #endif /* pr_vdebug */
 #  define ffs_dump_mem(prefix, ptr, len) do { } while (0)
 #endif /* VERBOSE_DEBUG */

 struct f_fs_opts;

 struct ffs_dev {
 	struct ffs_data *ffs_data;
 	struct f_fs_opts *opts;
 	struct list_head entry;

 	char name[41];

 	bool mounted;
 	bool desc_ready;
 	bool single;

 	int (*ffs_ready_callback)(struct ffs_data *ffs);
 	void (*ffs_closed_callback)(struct ffs_data *ffs);
 	void *(*ffs_acquire_dev_callback)(struct ffs_dev *dev);
 	void (*ffs_release_dev_callback)(struct ffs_dev *dev);
 };

 extern struct mutex ffs_lock;

 static inline void ffs_dev_lock(void)
 {
 	mutex_lock(&ffs_lock);
 }

 static inline void ffs_dev_unlock(void)
 {
 	mutex_unlock(&ffs_lock);
 }

 int ffs_name_dev(struct ffs_dev *dev, const char *name);
 int ffs_single_dev(struct ffs_dev *dev);

 struct ffs_epfile;
 struct ffs_function;

 enum ffs_state {
 	/*
 	 * Waiting for descriptors and strings.
 	 *
 	 * In this state no open(2), read(2) or write(2) on epfiles
 	 * may succeed (which should not be the problem as there
 	 * should be no such files opened in the first place).
 	 */
 	FFS_READ_DESCRIPTORS,
 	FFS_READ_STRINGS,

 	/*
 	 * We've got descriptors and strings.  We are or have called
 	 * functionfs_ready_callback().  functionfs_bind() may have
 	 * been called but we don't know.
 	 *
 	 * This is the only state in which operations on epfiles may
 	 * succeed.
 	 */
 	FFS_ACTIVE,

 	/*
 	 * Function is visible to host, but it's not functional. All
 	 * setup requests are stalled and transfers on another endpoints
 	 * are refused. All epfiles, except ep0, are deleted so there
 	 * is no way to perform any operations on them.
 	 *
 	 * This state is set after closing all functionfs files, when
 	 * mount parameter "no_disconnect=1" has been set. Function will
 	 * remain in deactivated state until filesystem is umounted or
 	 * ep0 is opened again. In the second case functionfs state will
 	 * be reset, and it will be ready for descriptors and strings
 	 * writing.
 	 *
 	 * This is useful only when functionfs is composed to gadget
 	 * with another function which can perform some critical
 	 * operations, and it's strongly desired to have this operations
 	 * completed, even after functionfs files closure.
 	 */
 	FFS_DEACTIVATED,

 	/*
 	 * All endpoints have been closed.  This state is also set if
 	 * we encounter an unrecoverable error.  The only
 	 * unrecoverable error is situation when after reading strings
 	 * from user space we fail to initialise epfiles or
 	 * functionfs_ready_callback() returns with error (<0).
 	 *
 	 * In this state no open(2), read(2) or write(2) (both on ep0
 	 * as well as epfile) may succeed (at this point epfiles are
 	 * unlinked and all closed so this is not a problem; ep0 is
 	 * also closed but ep0 file exists and so open(2) on ep0 must
 	 * fail).
 	 */
 	FFS_CLOSING
 };

 enum ffs_setup_state {
 	/* There is no setup request pending. */
 	FFS_NO_SETUP,
 	/*
 	 * User has read events and there was a setup request event
 	 * there.  The next read/write on ep0 will handle the
 	 * request.
 	 */
 	FFS_SETUP_PENDING,
 	/*
 	 * There was event pending but before user space handled it
 	 * some other event was introduced which canceled existing
 	 * setup.  If this state is set read/write on ep0 return
 	 * -EIDRM.  This state is only set when adding event.
 	 */
 	FFS_SETUP_CANCELLED
 };

 struct ffs_data {
 	struct usb_gadget		*gadget;

 	/*
 	 * Protect access read/write operations, only one read/write
 	 * at a time.  As a consequence protects ep0req and company.
 	 * While setup request is being processed (queued) this is
 	 * held.
 	 */
 	struct mutex			mutex;

 	/*
 	 * Protect access to endpoint related structures (basically
 	 * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
 	 * endpoint zero.
 	 */
 	spinlock_t			eps_lock;

 	/*
 	 * XXX REVISIT do we need our own request? Since we are not
 	 * handling setup requests immediately user space may be so
 	 * slow that another setup will be sent to the gadget but this
 	 * time not to us but another function and then there could be
 	 * a race.  Is that the case? Or maybe we can use cdev->req
 	 * after all, maybe we just need some spinlock for that?
 	 */
 	struct usb_request		*ep0req;		/* P: mutex */
 	struct completion		ep0req_completion;	/* P: mutex */

 	/* reference counter */
 	refcount_t			ref;
 	/* how many files are opened (EP0 and others) */
 	atomic_t			opened;

 	/* EP0 state */
 	enum ffs_state			state;

 	/*
 	 * Possible transitions:
 	 * + FFS_NO_SETUP        -> FFS_SETUP_PENDING  -- P: ev.waitq.lock
 	 *               happens only in ep0 read which is P: mutex
 	 * + FFS_SETUP_PENDING   -> FFS_NO_SETUP       -- P: ev.waitq.lock
 	 *               happens only in ep0 i/o  which is P: mutex
 	 * + FFS_SETUP_PENDING   -> FFS_SETUP_CANCELLED -- P: ev.waitq.lock
 	 * + FFS_SETUP_CANCELLED -> FFS_NO_SETUP        -- cmpxchg
 	 *
 	 * This field should never be accessed directly and instead
 	 * ffs_setup_state_clear_cancelled function should be used.
 	 */
 	enum ffs_setup_state		setup_state;

 	/* Events & such. */
 	struct {
 		u8				types[4];
 		unsigned short			count;
 		/* XXX REVISIT need to update it in some places, or do we? */
 		unsigned short			can_stall;
 		struct usb_ctrlrequest		setup;

 		wait_queue_head_t		waitq;
 	} ev; /* the whole structure, P: ev.waitq.lock */

 	/* Flags */
 	unsigned long			flags;
 #define FFS_FL_CALL_CLOSED_CALLBACK 0
 #define FFS_FL_BOUND                1

 	/* For waking up blocked threads when function is enabled. */
 	wait_queue_head_t		wait;

 	/* Active function */
 	struct ffs_function		*func;

 	/*
 	 * Device name, write once when file system is mounted.
 	 * Intended for user to read if she wants.
 	 */
 	const char			*dev_name;
 	/* Private data for our user (ie. gadget).  Managed by user. */
 	void				*private_data;

 	/* filled by __ffs_data_got_descs() */
 	/*
 	 * raw_descs is what you kfree, real_descs points inside of raw_descs,
 	 * where full speed, high speed and super speed descriptors start.
 	 * real_descs_length is the length of all those descriptors.
 	 */
 	const void			*raw_descs_data;
 	const void			*raw_descs;
 	unsigned			raw_descs_length;
 	unsigned			fs_descs_count;
 	unsigned			hs_descs_count;
 	unsigned			ss_descs_count;
 	unsigned			ms_os_descs_count;
 	unsigned			ms_os_descs_ext_prop_count;
 	unsigned			ms_os_descs_ext_prop_name_len;
 	unsigned			ms_os_descs_ext_prop_data_len;
 	void				*ms_os_descs_ext_prop_avail;
 	void				*ms_os_descs_ext_prop_name_avail;
 	void				*ms_os_descs_ext_prop_data_avail;

 	unsigned			user_flags;

 #define FFS_MAX_EPS_COUNT 31
 	u8				eps_addrmap[FFS_MAX_EPS_COUNT];

 	unsigned short			strings_count;
 	unsigned short			interfaces_count;
 	unsigned short			eps_count;
 	unsigned short			_pad1;

 	/* filled by __ffs_data_got_strings() */
 	/* ids in stringtabs are set in functionfs_bind() */
 	const void			*raw_strings;
 	struct usb_gadget_strings	**stringtabs;

 	/*
 	 * File system's super block, write once when file system is
 	 * mounted.
 	 */
 	struct super_block		*sb;

 	/* File permissions, written once when fs is mounted */
 	struct ffs_file_perms {
 		umode_t				mode;
 		kuid_t				uid;
 		kgid_t				gid;
 	}				file_perms;

 	struct eventfd_ctx *ffs_eventfd;
 	struct workqueue_struct *io_completion_wq;
 	bool no_disconnect;
 	struct work_struct reset_work;

 	/*
 	 * The endpoint files, filled by ffs_epfiles_create(),
 	 * destroyed by ffs_epfiles_destroy().
 	 */
 	struct ffs_epfile		*epfiles;
 };


 struct f_fs_opts {
 	struct usb_function_instance	func_inst;
 	struct ffs_dev			*dev;
 	unsigned			refcnt;
 	bool				no_configfs;
 };

 static inline struct f_fs_opts *to_f_fs_opts(struct usb_function_instance *fi)
 {
 	return container_of(fi, struct f_fs_opts, func_inst);
 }

 #endif /* U_FFS_H */
	/* SPDX-License-Identifier: GPL-2.0 */
	/*
	* u_fs.h
	*
	* Utility definitions for the FunctionFS
	*
	* Copyright (c) 2013 Samsung Electronics Co., Ltd.
	* http://www.samsung.com
	*
	* Author: Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>
	*/

	#ifndef U_FFS_H
	#define U_FFS_H

	#include <linux/usb/composite.h>
	#include <linux/list.h>
	#include <linux/mutex.h>
	#include <linux/workqueue.h>
	#include <linux/refcount.h>

	#ifdef VERBOSE_DEBUG
	#ifndef pr_vdebug
	# define pr_vdebug pr_debug
	#endif /* pr_vdebug */
	# define ffs_dump_mem(prefix, ptr, len) \
	print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
	#else
	#ifndef pr_vdebug
	# define pr_vdebug(...) do { } while (0)
	#endif /* pr_vdebug */
	# define ffs_dump_mem(prefix, ptr, len) do { } while (0)
	#endif /* VERBOSE_DEBUG */

	struct f_fs_opts;

	struct ffs_dev {
	struct ffs_data *ffs_data;
	struct f_fs_opts *opts;
	struct list_head entry;

	char name[41];

	bool mounted;
	bool desc_ready;
	bool single;

	int (ffs_ready_callback)(struct ffs_data ffs);
	void (ffs_closed_callback)(struct ffs_data ffs);
	void (ffs_acquire_dev_callback)(struct ffs_dev *dev);
	void (ffs_release_dev_callback)(struct ffs_dev dev);
	};

	extern struct mutex ffs_lock;

	static inline void ffs_dev_lock(void)
	{
	mutex_lock(&ffs_lock);
	}

	static inline void ffs_dev_unlock(void)
	{
	mutex_unlock(&ffs_lock);
	}

	int ffs_name_dev(struct ffs_dev dev, const char name);
	int ffs_single_dev(struct ffs_dev *dev);

	struct ffs_epfile;
	struct ffs_function;

	enum ffs_state {
	/*
	* Waiting for descriptors and strings.
	*
	* In this state no open(2), read(2) or write(2) on epfiles
	* may succeed (which should not be the problem as there
	* should be no such files opened in the first place).
	*/
	FFS_READ_DESCRIPTORS,
	FFS_READ_STRINGS,

	/*
	* We've got descriptors and strings. We are or have called
	* functionfs_ready_callback(). functionfs_bind() may have
	* been called but we don't know.
	*
	* This is the only state in which operations on epfiles may
	* succeed.
	*/
	FFS_ACTIVE,

	/*
	* Function is visible to host, but it's not functional. All
	* setup requests are stalled and transfers on another endpoints
	* are refused. All epfiles, except ep0, are deleted so there
	* is no way to perform any operations on them.
	*
	* This state is set after closing all functionfs files, when
	* mount parameter "no_disconnect=1" has been set. Function will
	* remain in deactivated state until filesystem is umounted or
	* ep0 is opened again. In the second case functionfs state will
	* be reset, and it will be ready for descriptors and strings
	* writing.
	*
	* This is useful only when functionfs is composed to gadget
	* with another function which can perform some critical
	* operations, and it's strongly desired to have this operations
	* completed, even after functionfs files closure.
	*/
	FFS_DEACTIVATED,

	/*
	* All endpoints have been closed. This state is also set if
	* we encounter an unrecoverable error. The only
	* unrecoverable error is situation when after reading strings
	* from user space we fail to initialise epfiles or
	* functionfs_ready_callback() returns with error (<0).
	*
	* In this state no open(2), read(2) or write(2) (both on ep0
	* as well as epfile) may succeed (at this point epfiles are
	* unlinked and all closed so this is not a problem; ep0 is
	* also closed but ep0 file exists and so open(2) on ep0 must
	* fail).
	*/
	FFS_CLOSING
	};

	enum ffs_setup_state {
	/* There is no setup request pending. */
	FFS_NO_SETUP,
	/*
	* User has read events and there was a setup request event
	* there. The next read/write on ep0 will handle the
	* request.
	*/
	FFS_SETUP_PENDING,
	/*
	* There was event pending but before user space handled it
	* some other event was introduced which canceled existing
	* setup. If this state is set read/write on ep0 return
	* -EIDRM. This state is only set when adding event.
	*/
	FFS_SETUP_CANCELLED
	};

	struct ffs_data {
	struct usb_gadget *gadget;

	/*
	* Protect access read/write operations, only one read/write
	* at a time. As a consequence protects ep0req and company.
	* While setup request is being processed (queued) this is
	* held.
	*/
	struct mutex mutex;

	/*
	* Protect access to endpoint related structures (basically
	* usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
	* endpoint zero.
	*/
	spinlock_t eps_lock;

	/*
	* XXX REVISIT do we need our own request? Since we are not
	* handling setup requests immediately user space may be so
	* slow that another setup will be sent to the gadget but this
	* time not to us but another function and then there could be
	* a race. Is that the case? Or maybe we can use cdev->req
	* after all, maybe we just need some spinlock for that?
	*/
	struct usb_request ep0req; / P: mutex */
	struct completion ep0req_completion; /* P: mutex */

	/* reference counter */
	refcount_t ref;
	/* how many files are opened (EP0 and others) */
	atomic_t opened;

	/* EP0 state */
	enum ffs_state state;

	/*
	* Possible transitions:
	* + FFS_NO_SETUP -> FFS_SETUP_PENDING -- P: ev.waitq.lock
	* happens only in ep0 read which is P: mutex
	* + FFS_SETUP_PENDING -> FFS_NO_SETUP -- P: ev.waitq.lock
	* happens only in ep0 i/o which is P: mutex
	* + FFS_SETUP_PENDING -> FFS_SETUP_CANCELLED -- P: ev.waitq.lock
	* + FFS_SETUP_CANCELLED -> FFS_NO_SETUP -- cmpxchg
	*
	* This field should never be accessed directly and instead
	* ffs_setup_state_clear_cancelled function should be used.
	*/
	enum ffs_setup_state setup_state;

	/* Events & such. */
	struct {
	u8 types[4];
	unsigned short count;
	/* XXX REVISIT need to update it in some places, or do we? */
	unsigned short can_stall;
	struct usb_ctrlrequest setup;

	wait_queue_head_t waitq;
	} ev; /* the whole structure, P: ev.waitq.lock */

	/* Flags */
	unsigned long flags;
	#define FFS_FL_CALL_CLOSED_CALLBACK 0
	#define FFS_FL_BOUND 1

	/* For waking up blocked threads when function is enabled. */
	wait_queue_head_t wait;

	/* Active function */
	struct ffs_function *func;

	/*
	* Device name, write once when file system is mounted.
	* Intended for user to read if she wants.
	*/
	const char *dev_name;
	/* Private data for our user (ie. gadget). Managed by user. */
	void *private_data;

	/* filled by __ffs_data_got_descs() */
	/*
	* raw_descs is what you kfree, real_descs points inside of raw_descs,
	* where full speed, high speed and super speed descriptors start.
	* real_descs_length is the length of all those descriptors.
	*/
	const void *raw_descs_data;
	const void *raw_descs;
	unsigned raw_descs_length;
	unsigned fs_descs_count;
	unsigned hs_descs_count;
	unsigned ss_descs_count;
	unsigned ms_os_descs_count;
	unsigned ms_os_descs_ext_prop_count;
	unsigned ms_os_descs_ext_prop_name_len;
	unsigned ms_os_descs_ext_prop_data_len;
	void *ms_os_descs_ext_prop_avail;
	void *ms_os_descs_ext_prop_name_avail;
	void *ms_os_descs_ext_prop_data_avail;

	unsigned user_flags;

	#define FFS_MAX_EPS_COUNT 31
	u8 eps_addrmap[FFS_MAX_EPS_COUNT];

	unsigned short strings_count;
	unsigned short interfaces_count;
	unsigned short eps_count;
	unsigned short _pad1;

	/* filled by __ffs_data_got_strings() */
	/* ids in stringtabs are set in functionfs_bind() */
	const void *raw_strings;
	struct usb_gadget_strings **stringtabs;

	/*
	* File system's super block, write once when file system is
	* mounted.
	*/
	struct super_block *sb;

	/* File permissions, written once when fs is mounted */
	struct ffs_file_perms {
	umode_t mode;
	kuid_t uid;
	kgid_t gid;
	} file_perms;

	struct eventfd_ctx *ffs_eventfd;
	struct workqueue_struct *io_completion_wq;
	bool no_disconnect;
	struct work_struct reset_work;

	/*
	* The endpoint files, filled by ffs_epfiles_create(),
	* destroyed by ffs_epfiles_destroy().
	*/
	struct ffs_epfile *epfiles;
	};


	struct f_fs_opts {
	struct usb_function_instance func_inst;
	struct ffs_dev *dev;
	unsigned refcnt;
	bool no_configfs;
	};

	static inline struct f_fs_opts to_f_fs_opts(struct usb_function_instance fi)
	{
	return container_of(fi, struct f_fs_opts, func_inst);
	}

	#endif /* U_FFS_H */