drivers/usb/gadget/function/u_fs.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * u_fs.h
   4  *
   5  * Utility definitions for the FunctionFS
   6  *
   7  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
   8  *              http://www.samsung.com
   9  *
  10  * Author: Andrzej Pietrasiewicz <[email protected]>
  11  */
  12
  13 #ifndef U_FFS_H
  14 #define U_FFS_H
  15
  16 #include <linux/usb/composite.h>
  17 #include <linux/list.h>
  18 #include <linux/mutex.h>
  19 #include <linux/workqueue.h>
  20 #include <linux/refcount.h>
  21
  22 #ifdef VERBOSE_DEBUG
  23 #ifndef pr_vdebug
  24 #  define pr_vdebug pr_debug
  25 #endif /* pr_vdebug */
  26 #  define ffs_dump_mem(prefix, ptr, len) \
  27         print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
  28 #else
  29 #ifndef pr_vdebug
  30 #  define pr_vdebug(...)                 do { } while (0)
  31 #endif /* pr_vdebug */
  32 #  define ffs_dump_mem(prefix, ptr, len) do { } while (0)
  33 #endif /* VERBOSE_DEBUG */
  34
  35 struct f_fs_opts;
  36
  37 struct ffs_dev {
  38         struct ffs_data *ffs_data;
  39         struct f_fs_opts *opts;
  40         struct list_head entry;
  41
  42         char name[41];
  43
  44         bool mounted;
  45         bool desc_ready;
  46         bool single;
  47
  48         int (*ffs_ready_callback)(struct ffs_data *ffs);
  49         void (*ffs_closed_callback)(struct ffs_data *ffs);
  50         void *(*ffs_acquire_dev_callback)(struct ffs_dev *dev);
  51         void (*ffs_release_dev_callback)(struct ffs_dev *dev);
  52 };
  53
  54 extern struct mutex ffs_lock;
  55
  56 static inline void ffs_dev_lock(void)
  57 {
  58         mutex_lock(&ffs_lock);
  59 }
  60
  61 static inline void ffs_dev_unlock(void)
  62 {
  63         mutex_unlock(&ffs_lock);
  64 }
  65
  66 int ffs_name_dev(struct ffs_dev *dev, const char *name);
  67 int ffs_single_dev(struct ffs_dev *dev);
  68
  69 struct ffs_epfile;
  70 struct ffs_function;
  71
  72 enum ffs_state {
  73         /*
  74          * Waiting for descriptors and strings.
  75          *
  76          * In this state no open(2), read(2) or write(2) on epfiles
  77          * may succeed (which should not be the problem as there
  78          * should be no such files opened in the first place).
  79          */
  80         FFS_READ_DESCRIPTORS,
  81         FFS_READ_STRINGS,
  82
  83         /*
  84          * We've got descriptors and strings.  We are or have called
  85          * functionfs_ready_callback().  functionfs_bind() may have
  86          * been called but we don't know.
  87          *
  88          * This is the only state in which operations on epfiles may
  89          * succeed.
  90          */
  91         FFS_ACTIVE,
  92
  93         /*
  94          * Function is visible to host, but it's not functional. All
  95          * setup requests are stalled and transfers on another endpoints
  96          * are refused. All epfiles, except ep0, are deleted so there
  97          * is no way to perform any operations on them.
  98          *
  99          * This state is set after closing all functionfs files, when
 100          * mount parameter "no_disconnect=1" has been set. Function will
 101          * remain in deactivated state until filesystem is umounted or
 102          * ep0 is opened again. In the second case functionfs state will
 103          * be reset, and it will be ready for descriptors and strings
 104          * writing.
 105          *
 106          * This is useful only when functionfs is composed to gadget
 107          * with another function which can perform some critical
 108          * operations, and it's strongly desired to have this operations
 109          * completed, even after functionfs files closure.
 110          */
 111         FFS_DEACTIVATED,
 112
 113         /*
 114          * All endpoints have been closed.  This state is also set if
 115          * we encounter an unrecoverable error.  The only
 116          * unrecoverable error is situation when after reading strings
 117          * from user space we fail to initialise epfiles or
 118          * functionfs_ready_callback() returns with error (<0).
 119          *
 120          * In this state no open(2), read(2) or write(2) (both on ep0
 121          * as well as epfile) may succeed (at this point epfiles are
 122          * unlinked and all closed so this is not a problem; ep0 is
 123          * also closed but ep0 file exists and so open(2) on ep0 must
 124          * fail).
 125          */
 126         FFS_CLOSING
 127 };
 128
 129 enum ffs_setup_state {
 130         /* There is no setup request pending. */
 131         FFS_NO_SETUP,
 132         /*
 133          * User has read events and there was a setup request event
 134          * there.  The next read/write on ep0 will handle the
 135          * request.
 136          */
 137         FFS_SETUP_PENDING,
 138         /*
 139          * There was event pending but before user space handled it
 140          * some other event was introduced which canceled existing
 141          * setup.  If this state is set read/write on ep0 return
 142          * -EIDRM.  This state is only set when adding event.
 143          */
 144         FFS_SETUP_CANCELLED
 145 };
 146
 147 struct ffs_data {
 148         struct usb_gadget               *gadget;
 149
 150         /*
 151          * Protect access read/write operations, only one read/write
 152          * at a time.  As a consequence protects ep0req and company.
 153          * While setup request is being processed (queued) this is
 154          * held.
 155          */
 156         struct mutex                    mutex;
 157
 158         /*
 159          * Protect access to endpoint related structures (basically
 160          * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
 161          * endpoint zero.
 162          */
 163         spinlock_t                      eps_lock;
 164
 165         /*
 166          * XXX REVISIT do we need our own request? Since we are not
 167          * handling setup requests immediately user space may be so
 168          * slow that another setup will be sent to the gadget but this
 169          * time not to us but another function and then there could be
 170          * a race.  Is that the case? Or maybe we can use cdev->req
 171          * after all, maybe we just need some spinlock for that?
 172          */
 173         struct usb_request              *ep0req;                /* P: mutex */
 174         struct completion               ep0req_completion;      /* P: mutex */
 175
 176         /* reference counter */
 177         refcount_t                      ref;
 178         /* how many files are opened (EP0 and others) */
 179         atomic_t                        opened;
 180
 181         /* EP0 state */
 182         enum ffs_state                  state;
 183
 184         /*
 185          * Possible transitions:
 186          * + FFS_NO_SETUP        -> FFS_SETUP_PENDING  -- P: ev.waitq.lock
 187          *               happens only in ep0 read which is P: mutex
 188          * + FFS_SETUP_PENDING   -> FFS_NO_SETUP       -- P: ev.waitq.lock
 189          *               happens only in ep0 i/o  which is P: mutex
 190          * + FFS_SETUP_PENDING   -> FFS_SETUP_CANCELLED -- P: ev.waitq.lock
 191          * + FFS_SETUP_CANCELLED -> FFS_NO_SETUP        -- cmpxchg
 192          *
 193          * This field should never be accessed directly and instead
 194          * ffs_setup_state_clear_cancelled function should be used.
 195          */
 196         enum ffs_setup_state            setup_state;
 197
 198         /* Events & such. */
 199         struct {
 200                 u8                              types[4];
 201                 unsigned short                  count;
 202                 /* XXX REVISIT need to update it in some places, or do we? */
 203                 unsigned short                  can_stall;
 204                 struct usb_ctrlrequest          setup;
 205
 206                 wait_queue_head_t               waitq;
 207         } ev; /* the whole structure, P: ev.waitq.lock */
 208
 209         /* Flags */
 210         unsigned long                   flags;
 211 #define FFS_FL_CALL_CLOSED_CALLBACK 0
 212 #define FFS_FL_BOUND                1
 213
 214         /* For waking up blocked threads when function is enabled. */
 215         wait_queue_head_t               wait;
 216
 217         /* Active function */
 218         struct ffs_function             *func;
 219
 220         /*
 221          * Device name, write once when file system is mounted.
 222          * Intended for user to read if she wants.
 223          */
 224         const char                      *dev_name;
 225         /* Private data for our user (ie. gadget).  Managed by user. */
 226         void                            *private_data;
 227
 228         /* filled by __ffs_data_got_descs() */
 229         /*
 230          * raw_descs is what you kfree, real_descs points inside of raw_descs,
 231          * where full speed, high speed and super speed descriptors start.
 232          * real_descs_length is the length of all those descriptors.
 233          */
 234         const void                      *raw_descs_data;
 235         const void                      *raw_descs;
 236         unsigned                        raw_descs_length;
 237         unsigned                        fs_descs_count;
 238         unsigned                        hs_descs_count;
 239         unsigned                        ss_descs_count;
 240         unsigned                        ms_os_descs_count;
 241         unsigned                        ms_os_descs_ext_prop_count;
 242         unsigned                        ms_os_descs_ext_prop_name_len;
 243         unsigned                        ms_os_descs_ext_prop_data_len;
 244         void                            *ms_os_descs_ext_prop_avail;
 245         void                            *ms_os_descs_ext_prop_name_avail;
 246         void                            *ms_os_descs_ext_prop_data_avail;
 247
 248         unsigned                        user_flags;
 249
 250 #define FFS_MAX_EPS_COUNT 31
 251         u8                              eps_addrmap[FFS_MAX_EPS_COUNT];
 252
 253         unsigned short                  strings_count;
 254         unsigned short                  interfaces_count;
 255         unsigned short                  eps_count;
 256         unsigned short                  _pad1;
 257
 258         /* filled by __ffs_data_got_strings() */
 259         /* ids in stringtabs are set in functionfs_bind() */
 260         const void                      *raw_strings;
 261         struct usb_gadget_strings       **stringtabs;
 262
 263         /*
 264          * File system's super block, write once when file system is
 265          * mounted.
 266          */
 267         struct super_block              *sb;
 268
 269         /* File permissions, written once when fs is mounted */
 270         struct ffs_file_perms {
 271                 umode_t                         mode;
 272                 kuid_t                          uid;
 273                 kgid_t                          gid;
 274         }                               file_perms;
 275
 276         struct eventfd_ctx *ffs_eventfd;
 277         struct workqueue_struct *io_completion_wq;
 278         bool no_disconnect;
 279         struct work_struct reset_work;
 280
 281         /*
 282          * The endpoint files, filled by ffs_epfiles_create(),
 283          * destroyed by ffs_epfiles_destroy().
 284          */
 285         struct ffs_epfile               *epfiles;
 286 };
 287
 288
 289 struct f_fs_opts {
 290         struct usb_function_instance    func_inst;
 291         struct ffs_dev                  *dev;
 292         unsigned                        refcnt;
 293         bool                            no_configfs;
 294 };
 295
 296 static inline struct f_fs_opts *to_f_fs_opts(struct usb_function_instance *fi)
 297 {
 298         return container_of(fi, struct f_fs_opts, func_inst);
 299 }
 300
 301 #endif /* U_FFS_H */