Commit | Line | Data |
---|---|---|
e72c39c0 AP |
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> | |
4b187fce AP |
20 | #include <linux/list.h> |
21 | #include <linux/mutex.h> | |
18d6b32f | 22 | #include <linux/workqueue.h> |
e72c39c0 | 23 | |
5920cda6 AP |
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 | ||
b658499f | 39 | struct f_fs_opts; |
5920cda6 | 40 | |
e72c39c0 AP |
41 | struct ffs_dev { |
42 | const char *name; | |
b658499f | 43 | bool name_allocated; |
e72c39c0 AP |
44 | bool mounted; |
45 | bool desc_ready; | |
4b187fce | 46 | bool single; |
e72c39c0 | 47 | struct ffs_data *ffs_data; |
b658499f | 48 | struct f_fs_opts *opts; |
4b187fce AP |
49 | struct list_head entry; |
50 | ||
51 | int (*ffs_ready_callback)(struct ffs_data *ffs); | |
52 | void (*ffs_closed_callback)(struct ffs_data *ffs); | |
5920cda6 AP |
53 | void *(*ffs_acquire_dev_callback)(struct ffs_dev *dev); |
54 | void (*ffs_release_dev_callback)(struct ffs_dev *dev); | |
e72c39c0 AP |
55 | }; |
56 | ||
4b187fce AP |
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 | ||
4b187fce AP |
69 | int ffs_name_dev(struct ffs_dev *dev, const char *name); |
70 | int ffs_single_dev(struct ffs_dev *dev); | |
4b187fce | 71 | |
5920cda6 AP |
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 | ||
18d6b32f RB |
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 | ||
5920cda6 AP |
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 | */ | |
e46318a0 | 147 | FFS_SETUP_CANCELLED |
5920cda6 AP |
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 */ | |
5920cda6 AP |
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: | |
e46318a0 | 189 | * + FFS_NO_SETUP -> FFS_SETUP_PENDING -- P: ev.waitq.lock |
5920cda6 | 190 | * happens only in ep0 read which is P: mutex |
e46318a0 | 191 | * + FFS_SETUP_PENDING -> FFS_NO_SETUP -- P: ev.waitq.lock |
5920cda6 | 192 | * happens only in ep0 i/o which is P: mutex |
e46318a0 MN |
193 | * + FFS_SETUP_PENDING -> FFS_SETUP_CANCELLED -- P: ev.waitq.lock |
194 | * + FFS_SETUP_CANCELLED -> FFS_NO_SETUP -- cmpxchg | |
a7ecf054 MN |
195 | * |
196 | * This field should never be accessed directly and instead | |
197 | * ffs_setup_state_clear_cancelled function should be used. | |
5920cda6 AP |
198 | */ |
199 | enum ffs_setup_state setup_state; | |
200 | ||
5920cda6 AP |
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 | /* | |
ac8dde11 MN |
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. | |
5920cda6 | 233 | */ |
ac8dde11 | 234 | const void *raw_descs_data; |
5920cda6 | 235 | const void *raw_descs; |
ac8dde11 | 236 | unsigned raw_descs_length; |
5920cda6 AP |
237 | unsigned fs_descs_count; |
238 | unsigned hs_descs_count; | |
8d4e897b | 239 | unsigned ss_descs_count; |
f0175ab5 AP |
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; | |
5920cda6 | 247 | |
1b0bf88f RB |
248 | unsigned user_flags; |
249 | ||
6d5c1c77 RB |
250 | u8 eps_addrmap[15]; |
251 | ||
5920cda6 AP |
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 | ||
5e33f6fd | 275 | struct eventfd_ctx *ffs_eventfd; |
18d6b32f RB |
276 | bool no_disconnect; |
277 | struct work_struct reset_work; | |
278 | ||
5920cda6 AP |
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 | ||
5920cda6 AP |
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 | } | |
5920cda6 | 298 | |
e72c39c0 | 299 | #endif /* U_FFS_H */ |