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