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