Quelle  u_fs.h   Sprache: C

/* 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 */