Commit | Line | Data |
---|---|---|
34e95e41 IPG |
1 | /* |
2 | * WiMedia Logical Link Control Protocol (WLP) | |
3 | * | |
4 | * Copyright (C) 2005-2006 Intel Corporation | |
5 | * Reinette Chatre <reinette.chatre@intel.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or | |
8 | * modify it under the terms of the GNU General Public License version | |
9 | * 2 as published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
19 | * 02110-1301, USA. | |
20 | * | |
21 | * | |
22 | * FIXME: docs | |
23 | * | |
24 | * - Does not (yet) include support for WLP control frames | |
25 | * WLP Draft 0.99 [6.5]. | |
26 | * | |
27 | * A visual representation of the data structures. | |
28 | * | |
29 | * wssidB wssidB | |
30 | * ^ ^ | |
31 | * | | | |
32 | * wssidA wssidA | |
33 | * wlp interface { ^ ^ | |
34 | * ... | | | |
35 | * ... ... wssid wssid ... | |
36 | * wlp --- ... | | | |
37 | * }; neighbors --> neighbA --> neighbB | |
38 | * ... | |
39 | * wss | |
40 | * ... | |
41 | * eda cache --> neighborA --> neighborB --> neighborC ... | |
42 | */ | |
43 | ||
44 | #ifndef __LINUX__WLP_H_ | |
45 | #define __LINUX__WLP_H_ | |
46 | ||
47 | #include <linux/netdevice.h> | |
48 | #include <linux/skbuff.h> | |
49 | #include <linux/list.h> | |
50 | #include <linux/uwb.h> | |
51 | ||
52 | /** | |
53 | * WLP Protocol ID | |
54 | * WLP Draft 0.99 [6.2] | |
55 | * | |
56 | * The MUX header for all WLP frames | |
57 | */ | |
58 | #define WLP_PROTOCOL_ID 0x0100 | |
59 | ||
60 | /** | |
61 | * WLP Version | |
62 | * WLP version placed in the association frames (WLP 0.99 [6.6]) | |
63 | */ | |
64 | #define WLP_VERSION 0x10 | |
65 | ||
66 | /** | |
67 | * Bytes needed to print UUID as string | |
68 | */ | |
69 | #define WLP_WSS_UUID_STRSIZE 48 | |
70 | ||
71 | /** | |
72 | * Bytes needed to print nonce as string | |
73 | */ | |
74 | #define WLP_WSS_NONCE_STRSIZE 48 | |
75 | ||
76 | ||
77 | /** | |
78 | * Size used for WLP name size | |
79 | * | |
80 | * The WSS name is set to 65 bytes, 1 byte larger than the maximum | |
81 | * allowed by the WLP spec. This is to have a null terminated string | |
82 | * for display to the user. A maximum of 64 bytes will still be used | |
83 | * when placing the WSS name field in association frames. | |
84 | */ | |
85 | #define WLP_WSS_NAME_SIZE 65 | |
86 | ||
87 | /** | |
88 | * Number of bytes added by WLP to data frame | |
89 | * | |
90 | * A data frame transmitted from a host will be placed in a Standard or | |
91 | * Abbreviated WLP frame. These have an extra 4 bytes of header (struct | |
92 | * wlp_frame_std_abbrv_hdr). | |
93 | * When the stack sends this data frame for transmission it needs to ensure | |
94 | * there is enough headroom for this header. | |
95 | */ | |
96 | #define WLP_DATA_HLEN 4 | |
97 | ||
98 | /** | |
99 | * State of device regarding WLP Service Set | |
100 | * | |
101 | * WLP_WSS_STATE_NONE: the host does not participate in any WSS | |
102 | * WLP_WSS_STATE_PART_ENROLLED: used as part of the enrollment sequence | |
103 | * ("Partial Enroll"). This state is used to | |
104 | * indicate the first part of enrollment that is | |
105 | * unsecure. If the WSS is unsecure then the | |
106 | * state will promptly go to WLP_WSS_STATE_ENROLLED, | |
107 | * if the WSS is not secure then the enrollment | |
108 | * procedure is a few more steps before we are | |
109 | * enrolled. | |
110 | * WLP_WSS_STATE_ENROLLED: the host is enrolled in a WSS | |
111 | * WLP_WSS_STATE_ACTIVE: WSS is activated | |
112 | * WLP_WSS_STATE_CONNECTED: host is connected to neighbor in WSS | |
113 | * | |
114 | */ | |
115 | enum wlp_wss_state { | |
116 | WLP_WSS_STATE_NONE = 0, | |
117 | WLP_WSS_STATE_PART_ENROLLED, | |
118 | WLP_WSS_STATE_ENROLLED, | |
119 | WLP_WSS_STATE_ACTIVE, | |
120 | WLP_WSS_STATE_CONNECTED, | |
121 | }; | |
122 | ||
123 | /** | |
124 | * WSS Secure status | |
125 | * WLP 0.99 Table 6 | |
126 | * | |
127 | * Set to one if the WSS is secure, zero if it is not secure | |
128 | */ | |
129 | enum wlp_wss_sec_status { | |
130 | WLP_WSS_UNSECURE = 0, | |
131 | WLP_WSS_SECURE, | |
132 | }; | |
133 | ||
134 | /** | |
135 | * WLP frame type | |
136 | * WLP Draft 0.99 [6.2 Table 1] | |
137 | */ | |
138 | enum wlp_frame_type { | |
139 | WLP_FRAME_STANDARD = 0, | |
140 | WLP_FRAME_ABBREVIATED, | |
141 | WLP_FRAME_CONTROL, | |
142 | WLP_FRAME_ASSOCIATION, | |
143 | }; | |
144 | ||
145 | /** | |
146 | * WLP Association Message Type | |
147 | * WLP Draft 0.99 [6.6.1.2 Table 8] | |
148 | */ | |
149 | enum wlp_assoc_type { | |
150 | WLP_ASSOC_D1 = 2, | |
151 | WLP_ASSOC_D2 = 3, | |
152 | WLP_ASSOC_M1 = 4, | |
153 | WLP_ASSOC_M2 = 5, | |
154 | WLP_ASSOC_M3 = 7, | |
155 | WLP_ASSOC_M4 = 8, | |
156 | WLP_ASSOC_M5 = 9, | |
157 | WLP_ASSOC_M6 = 10, | |
158 | WLP_ASSOC_M7 = 11, | |
159 | WLP_ASSOC_M8 = 12, | |
160 | WLP_ASSOC_F0 = 14, | |
161 | WLP_ASSOC_E1 = 32, | |
162 | WLP_ASSOC_E2 = 33, | |
163 | WLP_ASSOC_C1 = 34, | |
164 | WLP_ASSOC_C2 = 35, | |
165 | WLP_ASSOC_C3 = 36, | |
166 | WLP_ASSOC_C4 = 37, | |
167 | }; | |
168 | ||
169 | /** | |
170 | * WLP Attribute Type | |
171 | * WLP Draft 0.99 [6.6.1 Table 6] | |
172 | */ | |
173 | enum wlp_attr_type { | |
174 | WLP_ATTR_AUTH = 0x1005, /* Authenticator */ | |
175 | WLP_ATTR_DEV_NAME = 0x1011, /* Device Name */ | |
176 | WLP_ATTR_DEV_PWD_ID = 0x1012, /* Device Password ID */ | |
177 | WLP_ATTR_E_HASH1 = 0x1014, /* E-Hash1 */ | |
178 | WLP_ATTR_E_HASH2 = 0x1015, /* E-Hash2 */ | |
179 | WLP_ATTR_E_SNONCE1 = 0x1016, /* E-SNonce1 */ | |
180 | WLP_ATTR_E_SNONCE2 = 0x1017, /* E-SNonce2 */ | |
181 | WLP_ATTR_ENCR_SET = 0x1018, /* Encrypted Settings */ | |
182 | WLP_ATTR_ENRL_NONCE = 0x101A, /* Enrollee Nonce */ | |
183 | WLP_ATTR_KEYWRAP_AUTH = 0x101E, /* Key Wrap Authenticator */ | |
184 | WLP_ATTR_MANUF = 0x1021, /* Manufacturer */ | |
185 | WLP_ATTR_MSG_TYPE = 0x1022, /* Message Type */ | |
186 | WLP_ATTR_MODEL_NAME = 0x1023, /* Model Name */ | |
187 | WLP_ATTR_MODEL_NR = 0x1024, /* Model Number */ | |
188 | WLP_ATTR_PUB_KEY = 0x1032, /* Public Key */ | |
189 | WLP_ATTR_REG_NONCE = 0x1039, /* Registrar Nonce */ | |
190 | WLP_ATTR_R_HASH1 = 0x103D, /* R-Hash1 */ | |
191 | WLP_ATTR_R_HASH2 = 0x103E, /* R-Hash2 */ | |
192 | WLP_ATTR_R_SNONCE1 = 0x103F, /* R-SNonce1 */ | |
193 | WLP_ATTR_R_SNONCE2 = 0x1040, /* R-SNonce2 */ | |
194 | WLP_ATTR_SERIAL = 0x1042, /* Serial number */ | |
195 | WLP_ATTR_UUID_E = 0x1047, /* UUID-E */ | |
196 | WLP_ATTR_UUID_R = 0x1048, /* UUID-R */ | |
197 | WLP_ATTR_PRI_DEV_TYPE = 0x1054, /* Primary Device Type */ | |
198 | WLP_ATTR_SEC_DEV_TYPE = 0x1055, /* Secondary Device Type */ | |
199 | WLP_ATTR_PORT_DEV = 0x1056, /* Portable Device */ | |
200 | WLP_ATTR_APP_EXT = 0x1058, /* Application Extension */ | |
201 | WLP_ATTR_WLP_VER = 0x2000, /* WLP Version */ | |
202 | WLP_ATTR_WSSID = 0x2001, /* WSSID */ | |
203 | WLP_ATTR_WSS_NAME = 0x2002, /* WSS Name */ | |
204 | WLP_ATTR_WSS_SEC_STAT = 0x2003, /* WSS Secure Status */ | |
205 | WLP_ATTR_WSS_BCAST = 0x2004, /* WSS Broadcast Address */ | |
206 | WLP_ATTR_WSS_M_KEY = 0x2005, /* WSS Master Key */ | |
207 | WLP_ATTR_ACC_ENRL = 0x2006, /* Accepting Enrollment */ | |
208 | WLP_ATTR_WSS_INFO = 0x2007, /* WSS Information */ | |
209 | WLP_ATTR_WSS_SEL_MTHD = 0x2008, /* WSS Selection Method */ | |
210 | WLP_ATTR_ASSC_MTHD_LIST = 0x2009, /* Association Methods List */ | |
211 | WLP_ATTR_SEL_ASSC_MTHD = 0x200A, /* Selected Association Method */ | |
212 | WLP_ATTR_ENRL_HASH_COMM = 0x200B, /* Enrollee Hash Commitment */ | |
213 | WLP_ATTR_WSS_TAG = 0x200C, /* WSS Tag */ | |
214 | WLP_ATTR_WSS_VIRT = 0x200D, /* WSS Virtual EUI-48 */ | |
215 | WLP_ATTR_WLP_ASSC_ERR = 0x200E, /* WLP Association Error */ | |
216 | WLP_ATTR_VNDR_EXT = 0x200F, /* Vendor Extension */ | |
217 | }; | |
218 | ||
219 | /** | |
220 | * WLP Category ID of primary/secondary device | |
221 | * WLP Draft 0.99 [6.6.1.8 Table 12] | |
222 | */ | |
223 | enum wlp_dev_category_id { | |
224 | WLP_DEV_CAT_COMPUTER = 1, | |
225 | WLP_DEV_CAT_INPUT, | |
226 | WLP_DEV_CAT_PRINT_SCAN_FAX_COPIER, | |
227 | WLP_DEV_CAT_CAMERA, | |
228 | WLP_DEV_CAT_STORAGE, | |
229 | WLP_DEV_CAT_INFRASTRUCTURE, | |
230 | WLP_DEV_CAT_DISPLAY, | |
231 | WLP_DEV_CAT_MULTIM, | |
232 | WLP_DEV_CAT_GAMING, | |
233 | WLP_DEV_CAT_TELEPHONE, | |
234 | WLP_DEV_CAT_OTHER = 65535, | |
235 | }; | |
236 | ||
237 | /** | |
238 | * WLP WSS selection method | |
239 | * WLP Draft 0.99 [6.6.1.6 Table 10] | |
240 | */ | |
241 | enum wlp_wss_sel_mthd { | |
242 | WLP_WSS_ENRL_SELECT = 1, /* Enrollee selects */ | |
243 | WLP_WSS_REG_SELECT, /* Registrar selects */ | |
244 | }; | |
245 | ||
246 | /** | |
247 | * WLP association error values | |
248 | * WLP Draft 0.99 [6.6.1.5 Table 9] | |
249 | */ | |
250 | enum wlp_assc_error { | |
251 | WLP_ASSOC_ERROR_NONE, | |
252 | WLP_ASSOC_ERROR_AUTH, /* Authenticator Failure */ | |
253 | WLP_ASSOC_ERROR_ROGUE, /* Rogue activity suspected */ | |
254 | WLP_ASSOC_ERROR_BUSY, /* Device busy */ | |
255 | WLP_ASSOC_ERROR_LOCK, /* Setup Locked */ | |
256 | WLP_ASSOC_ERROR_NOT_READY, /* Registrar not ready */ | |
257 | WLP_ASSOC_ERROR_INV, /* Invalid WSS selection */ | |
258 | WLP_ASSOC_ERROR_MSG_TIME, /* Message timeout */ | |
259 | WLP_ASSOC_ERROR_ENR_TIME, /* Enrollment session timeout */ | |
260 | WLP_ASSOC_ERROR_PW, /* Device password invalid */ | |
261 | WLP_ASSOC_ERROR_VER, /* Unsupported version */ | |
262 | WLP_ASSOC_ERROR_INT, /* Internal error */ | |
263 | WLP_ASSOC_ERROR_UNDEF, /* Undefined error */ | |
264 | WLP_ASSOC_ERROR_NUM, /* Numeric comparison failure */ | |
265 | WLP_ASSOC_ERROR_WAIT, /* Waiting for user input */ | |
266 | }; | |
267 | ||
268 | /** | |
269 | * WLP Parameters | |
270 | * WLP 0.99 [7.7] | |
271 | */ | |
272 | enum wlp_parameters { | |
273 | WLP_PER_MSG_TIMEOUT = 15, /* Seconds to wait for response to | |
274 | association message. */ | |
275 | }; | |
276 | ||
277 | /** | |
278 | * WLP IE | |
279 | * | |
280 | * The WLP IE should be included in beacons by all devices. | |
281 | * | |
282 | * The driver can set only a few of the fields in this information element, | |
283 | * most fields are managed by the device self. When the driver needs to set | |
284 | * a field it will only provide values for the fields of interest, the rest | |
285 | * will be filled with zeroes. The fields of interest are: | |
286 | * | |
287 | * Element ID | |
288 | * Length | |
289 | * Capabilities (only to include WSSID Hash list length) | |
290 | * WSSID Hash List fields | |
291 | * | |
292 | * WLP 0.99 [6.7] | |
293 | * | |
294 | * Only the fields that will be used are detailed in this structure, rest | |
295 | * are not detailed or marked as "notused". | |
296 | */ | |
297 | struct wlp_ie { | |
298 | struct uwb_ie_hdr hdr; | |
299 | __le16 capabilities; | |
300 | __le16 cycle_param; | |
301 | __le16 acw_anchor_addr; | |
302 | u8 wssid_hash_list[]; | |
303 | } __attribute__((packed)); | |
304 | ||
305 | static inline int wlp_ie_hash_length(struct wlp_ie *ie) | |
306 | { | |
307 | return (le16_to_cpu(ie->capabilities) >> 12) & 0xf; | |
308 | } | |
309 | ||
310 | static inline void wlp_ie_set_hash_length(struct wlp_ie *ie, int hash_length) | |
311 | { | |
312 | u16 caps = le16_to_cpu(ie->capabilities); | |
313 | caps = (caps & ~(0xf << 12)) | (hash_length << 12); | |
314 | ie->capabilities = cpu_to_le16(caps); | |
315 | } | |
316 | ||
317 | /** | |
318 | * WLP nonce | |
319 | * WLP Draft 0.99 [6.6.1 Table 6] | |
320 | * | |
321 | * A 128-bit random number often used (E-SNonce1, E-SNonce2, Enrollee | |
322 | * Nonce, Registrar Nonce, R-SNonce1, R-SNonce2). It is passed to HW so | |
323 | * it is packed. | |
324 | */ | |
325 | struct wlp_nonce { | |
326 | u8 data[16]; | |
327 | } __attribute__((packed)); | |
328 | ||
329 | /** | |
330 | * WLP UUID | |
331 | * WLP Draft 0.99 [6.6.1 Table 6] | |
332 | * | |
333 | * Universally Unique Identifier (UUID) encoded as an octet string in the | |
334 | * order the octets are shown in string representation in RFC4122. A UUID | |
335 | * is often used (UUID-E, UUID-R, WSSID). It is passed to HW so it is packed. | |
336 | */ | |
337 | struct wlp_uuid { | |
338 | u8 data[16]; | |
339 | } __attribute__((packed)); | |
340 | ||
341 | ||
342 | /** | |
343 | * Primary and secondary device type attributes | |
344 | * WLP Draft 0.99 [6.6.1.8] | |
345 | */ | |
346 | struct wlp_dev_type { | |
347 | enum wlp_dev_category_id category:16; | |
348 | u8 OUI[3]; | |
349 | u8 OUIsubdiv; | |
350 | __le16 subID; | |
351 | } __attribute__((packed)); | |
352 | ||
353 | /** | |
354 | * WLP frame header | |
355 | * WLP Draft 0.99 [6.2] | |
356 | */ | |
357 | struct wlp_frame_hdr { | |
358 | __le16 mux_hdr; /* WLP_PROTOCOL_ID */ | |
359 | enum wlp_frame_type type:8; | |
360 | } __attribute__((packed)); | |
361 | ||
362 | /** | |
363 | * WLP attribute field header | |
364 | * WLP Draft 0.99 [6.6.1] | |
365 | * | |
366 | * Header of each attribute found in an association frame | |
367 | */ | |
368 | struct wlp_attr_hdr { | |
369 | __le16 type; | |
370 | __le16 length; | |
371 | } __attribute__((packed)); | |
372 | ||
373 | /** | |
374 | * Device information commonly used together | |
375 | * | |
376 | * Each of these device information elements has a specified range in which it | |
377 | * should fit (WLP 0.99 [Table 6]). This range provided in the spec does not | |
378 | * include the termination null '\0' character (when used in the | |
379 | * association protocol the attribute fields are accompanied | |
380 | * with a "length" field so the full range from the spec can be used for | |
381 | * the value). We thus allocate an extra byte to be able to store a string | |
382 | * of max length with a terminating '\0'. | |
383 | */ | |
384 | struct wlp_device_info { | |
385 | char name[33]; | |
386 | char model_name[33]; | |
387 | char manufacturer[65]; | |
388 | char model_nr[33]; | |
389 | char serial[33]; | |
390 | struct wlp_dev_type prim_dev_type; | |
391 | }; | |
392 | ||
393 | /** | |
394 | * Macros for the WLP attributes | |
395 | * | |
396 | * There are quite a few attributes (total is 43). The attribute layout can be | |
397 | * in one of three categories: one value, an array, an enum forced to 8 bits. | |
398 | * These macros help with their definitions. | |
399 | */ | |
400 | #define wlp_attr(type, name) \ | |
401 | struct wlp_attr_##name { \ | |
402 | struct wlp_attr_hdr hdr; \ | |
403 | type name; \ | |
404 | } __attribute__((packed)); | |
405 | ||
406 | #define wlp_attr_array(type, name) \ | |
407 | struct wlp_attr_##name { \ | |
408 | struct wlp_attr_hdr hdr; \ | |
409 | type name[]; \ | |
410 | } __attribute__((packed)); | |
411 | ||
412 | /** | |
413 | * WLP association attribute fields | |
414 | * WLP Draft 0.99 [6.6.1 Table 6] | |
415 | * | |
416 | * Attributes appear in same order as the Table in the spec | |
417 | * FIXME Does not define all attributes yet | |
418 | */ | |
419 | ||
420 | /* Device name: Friendly name of sending device */ | |
421 | wlp_attr_array(u8, dev_name) | |
422 | ||
423 | /* Enrollee Nonce: Random number generated by enrollee for an enrollment | |
424 | * session */ | |
425 | wlp_attr(struct wlp_nonce, enonce) | |
426 | ||
427 | /* Manufacturer name: Name of manufacturer of the sending device */ | |
428 | wlp_attr_array(u8, manufacturer) | |
429 | ||
430 | /* WLP Message Type */ | |
431 | wlp_attr(u8, msg_type) | |
432 | ||
433 | /* WLP Model name: Model name of sending device */ | |
434 | wlp_attr_array(u8, model_name) | |
435 | ||
436 | /* WLP Model number: Model number of sending device */ | |
437 | wlp_attr_array(u8, model_nr) | |
438 | ||
439 | /* Registrar Nonce: Random number generated by registrar for an enrollment | |
440 | * session */ | |
441 | wlp_attr(struct wlp_nonce, rnonce) | |
442 | ||
443 | /* Serial number of device */ | |
444 | wlp_attr_array(u8, serial) | |
445 | ||
446 | /* UUID of enrollee */ | |
447 | wlp_attr(struct wlp_uuid, uuid_e) | |
448 | ||
449 | /* UUID of registrar */ | |
450 | wlp_attr(struct wlp_uuid, uuid_r) | |
451 | ||
452 | /* WLP Primary device type */ | |
453 | wlp_attr(struct wlp_dev_type, prim_dev_type) | |
454 | ||
455 | /* WLP Secondary device type */ | |
456 | wlp_attr(struct wlp_dev_type, sec_dev_type) | |
457 | ||
458 | /* WLP protocol version */ | |
459 | wlp_attr(u8, version) | |
460 | ||
461 | /* WLP service set identifier */ | |
462 | wlp_attr(struct wlp_uuid, wssid) | |
463 | ||
464 | /* WLP WSS name */ | |
465 | wlp_attr_array(u8, wss_name) | |
466 | ||
467 | /* WLP WSS Secure Status */ | |
468 | wlp_attr(u8, wss_sec_status) | |
469 | ||
470 | /* WSS Broadcast Address */ | |
471 | wlp_attr(struct uwb_mac_addr, wss_bcast) | |
472 | ||
473 | /* WLP Accepting Enrollment */ | |
474 | wlp_attr(u8, accept_enrl) | |
475 | ||
476 | /** | |
477 | * WSS information attributes | |
478 | * WLP Draft 0.99 [6.6.3 Table 15] | |
479 | */ | |
480 | struct wlp_wss_info { | |
481 | struct wlp_attr_wssid wssid; | |
482 | struct wlp_attr_wss_name name; | |
483 | struct wlp_attr_accept_enrl accept; | |
484 | struct wlp_attr_wss_sec_status sec_stat; | |
485 | struct wlp_attr_wss_bcast bcast; | |
486 | } __attribute__((packed)); | |
487 | ||
488 | /* WLP WSS Information */ | |
489 | wlp_attr_array(struct wlp_wss_info, wss_info) | |
490 | ||
491 | /* WLP WSS Selection method */ | |
492 | wlp_attr(u8, wss_sel_mthd) | |
493 | ||
494 | /* WLP WSS tag */ | |
495 | wlp_attr(u8, wss_tag) | |
496 | ||
497 | /* WSS Virtual Address */ | |
498 | wlp_attr(struct uwb_mac_addr, wss_virt) | |
499 | ||
500 | /* WLP association error */ | |
501 | wlp_attr(u8, wlp_assc_err) | |
502 | ||
503 | /** | |
504 | * WLP standard and abbreviated frames | |
505 | * | |
506 | * WLP Draft 0.99 [6.3] and [6.4] | |
507 | * | |
508 | * The difference between the WLP standard frame and the WLP | |
509 | * abbreviated frame is that the standard frame includes the src | |
510 | * and dest addresses from the Ethernet header, the abbreviated frame does | |
511 | * not. | |
512 | * The src/dest (as well as the type/length and client data) are already | |
513 | * defined as part of the Ethernet header, we do not do this here. | |
514 | * From this perspective the standard and abbreviated frames appear the | |
515 | * same - they will be treated differently though. | |
516 | * | |
517 | * The size of this header is also captured in WLP_DATA_HLEN to enable | |
518 | * interfaces to prepare their headroom. | |
519 | */ | |
520 | struct wlp_frame_std_abbrv_hdr { | |
521 | struct wlp_frame_hdr hdr; | |
522 | u8 tag; | |
523 | } __attribute__((packed)); | |
524 | ||
525 | /** | |
526 | * WLP association frames | |
527 | * | |
528 | * WLP Draft 0.99 [6.6] | |
529 | */ | |
530 | struct wlp_frame_assoc { | |
531 | struct wlp_frame_hdr hdr; | |
532 | enum wlp_assoc_type type:8; | |
533 | struct wlp_attr_version version; | |
534 | struct wlp_attr_msg_type msg_type; | |
535 | u8 attr[]; | |
536 | } __attribute__((packed)); | |
537 | ||
538 | /* Ethernet to dev address mapping */ | |
539 | struct wlp_eda { | |
540 | spinlock_t lock; | |
541 | struct list_head cache; /* Eth<->Dev Addr cache */ | |
542 | }; | |
543 | ||
544 | /** | |
545 | * WSS information temporary storage | |
546 | * | |
547 | * This information is only stored temporarily during discovery. It should | |
548 | * not be stored unless the device is enrolled in the advertised WSS. This | |
549 | * is done mainly because we follow the letter of the spec in this regard. | |
550 | * See WLP 0.99 [7.2.3]. | |
551 | * When the device does become enrolled in a WSS the WSS information will | |
552 | * be stored as part of the more comprehensive struct wlp_wss. | |
553 | */ | |
554 | struct wlp_wss_tmp_info { | |
555 | char name[WLP_WSS_NAME_SIZE]; | |
556 | u8 accept_enroll; | |
557 | u8 sec_status; | |
558 | struct uwb_mac_addr bcast; | |
559 | }; | |
560 | ||
561 | struct wlp_wssid_e { | |
562 | struct list_head node; | |
563 | struct wlp_uuid wssid; | |
564 | struct wlp_wss_tmp_info *info; | |
565 | }; | |
566 | ||
567 | /** | |
568 | * A cache entry of WLP neighborhood | |
569 | * | |
570 | * @node: head of list is wlp->neighbors | |
571 | * @wssid: list of wssids of this neighbor, element is wlp_wssid_e | |
572 | * @info: temporary storage for information learned during discovery. This | |
573 | * storage is used together with the wssid_e temporary storage | |
574 | * during discovery. | |
575 | */ | |
576 | struct wlp_neighbor_e { | |
577 | struct list_head node; | |
578 | struct wlp_uuid uuid; | |
579 | struct uwb_dev *uwb_dev; | |
580 | struct list_head wssid; /* Elements are wlp_wssid_e */ | |
581 | struct wlp_device_info *info; | |
582 | }; | |
583 | ||
584 | struct wlp; | |
585 | /** | |
586 | * Information for an association session in progress. | |
587 | * | |
588 | * @exp_message: The type of the expected message. Both this message and a | |
589 | * F0 message (which can be sent in response to any | |
590 | * association frame) will be accepted as a valid message for | |
591 | * this session. | |
592 | * @cb: The function that will be called upon receipt of this | |
593 | * message. | |
594 | * @cb_priv: Private data of callback | |
595 | * @data: Data used in association process (always a sk_buff?) | |
596 | * @neighbor: Address of neighbor with which association session is in | |
597 | * progress. | |
598 | */ | |
599 | struct wlp_session { | |
600 | enum wlp_assoc_type exp_message; | |
601 | void (*cb)(struct wlp *); | |
602 | void *cb_priv; | |
603 | void *data; | |
604 | struct uwb_dev_addr neighbor_addr; | |
605 | }; | |
606 | ||
607 | /** | |
608 | * WLP Service Set | |
609 | * | |
610 | * @mutex: used to protect entire WSS structure. | |
611 | * | |
612 | * @name: The WSS name is set to 65 bytes, 1 byte larger than the maximum | |
613 | * allowed by the WLP spec. This is to have a null terminated string | |
614 | * for display to the user. A maximum of 64 bytes will still be used | |
615 | * when placing the WSS name field in association frames. | |
616 | * | |
617 | * @accept_enroll: Accepting enrollment: Set to one if registrar is | |
618 | * accepting enrollment in WSS, or zero otherwise. | |
619 | * | |
620 | * Global and local information for each WSS in which we are enrolled. | |
621 | * WLP 0.99 Section 7.2.1 and Section 7.2.2 | |
622 | */ | |
623 | struct wlp_wss { | |
624 | struct mutex mutex; | |
625 | struct kobject kobj; | |
626 | /* Global properties. */ | |
627 | struct wlp_uuid wssid; | |
628 | u8 hash; | |
629 | char name[WLP_WSS_NAME_SIZE]; | |
630 | struct uwb_mac_addr bcast; | |
631 | u8 secure_status:1; | |
632 | u8 master_key[16]; | |
633 | /* Local properties. */ | |
634 | u8 tag; | |
635 | struct uwb_mac_addr virtual_addr; | |
636 | /* Extra */ | |
637 | u8 accept_enroll:1; | |
638 | enum wlp_wss_state state; | |
639 | }; | |
640 | ||
641 | /** | |
642 | * WLP main structure | |
643 | * @mutex: protect changes to WLP structure. We only allow changes to the | |
644 | * uuid, so currently this mutex only protects this field. | |
645 | */ | |
646 | struct wlp { | |
647 | struct mutex mutex; | |
648 | struct uwb_rc *rc; /* UWB radio controller */ | |
e8e1594c | 649 | struct net_device *ndev; |
34e95e41 IPG |
650 | struct uwb_pal pal; |
651 | struct wlp_eda eda; | |
652 | struct wlp_uuid uuid; | |
653 | struct wlp_session *session; | |
654 | struct wlp_wss wss; | |
655 | struct mutex nbmutex; /* Neighbor mutex protects neighbors list */ | |
656 | struct list_head neighbors; /* Elements are wlp_neighbor_e */ | |
657 | struct uwb_notifs_handler uwb_notifs_handler; | |
658 | struct wlp_device_info *dev_info; | |
659 | void (*fill_device_info)(struct wlp *wlp, struct wlp_device_info *info); | |
660 | int (*xmit_frame)(struct wlp *, struct sk_buff *, | |
661 | struct uwb_dev_addr *); | |
662 | void (*stop_queue)(struct wlp *); | |
663 | void (*start_queue)(struct wlp *); | |
664 | }; | |
665 | ||
666 | /* sysfs */ | |
667 | ||
668 | ||
669 | struct wlp_wss_attribute { | |
670 | struct attribute attr; | |
671 | ssize_t (*show)(struct wlp_wss *wss, char *buf); | |
672 | ssize_t (*store)(struct wlp_wss *wss, const char *buf, size_t count); | |
673 | }; | |
674 | ||
675 | #define WSS_ATTR(_name, _mode, _show, _store) \ | |
676 | static struct wlp_wss_attribute wss_attr_##_name = __ATTR(_name, _mode, \ | |
677 | _show, _store) | |
678 | ||
e8e1594c | 679 | extern int wlp_setup(struct wlp *, struct uwb_rc *, struct net_device *ndev); |
34e95e41 IPG |
680 | extern void wlp_remove(struct wlp *); |
681 | extern ssize_t wlp_neighborhood_show(struct wlp *, char *); | |
682 | extern int wlp_wss_setup(struct net_device *, struct wlp_wss *); | |
683 | extern void wlp_wss_remove(struct wlp_wss *); | |
684 | extern ssize_t wlp_wss_activate_show(struct wlp_wss *, char *); | |
685 | extern ssize_t wlp_wss_activate_store(struct wlp_wss *, const char *, size_t); | |
686 | extern ssize_t wlp_eda_show(struct wlp *, char *); | |
687 | extern ssize_t wlp_eda_store(struct wlp *, const char *, size_t); | |
688 | extern ssize_t wlp_uuid_show(struct wlp *, char *); | |
689 | extern ssize_t wlp_uuid_store(struct wlp *, const char *, size_t); | |
690 | extern ssize_t wlp_dev_name_show(struct wlp *, char *); | |
691 | extern ssize_t wlp_dev_name_store(struct wlp *, const char *, size_t); | |
692 | extern ssize_t wlp_dev_manufacturer_show(struct wlp *, char *); | |
693 | extern ssize_t wlp_dev_manufacturer_store(struct wlp *, const char *, size_t); | |
694 | extern ssize_t wlp_dev_model_name_show(struct wlp *, char *); | |
695 | extern ssize_t wlp_dev_model_name_store(struct wlp *, const char *, size_t); | |
696 | extern ssize_t wlp_dev_model_nr_show(struct wlp *, char *); | |
697 | extern ssize_t wlp_dev_model_nr_store(struct wlp *, const char *, size_t); | |
698 | extern ssize_t wlp_dev_serial_show(struct wlp *, char *); | |
699 | extern ssize_t wlp_dev_serial_store(struct wlp *, const char *, size_t); | |
700 | extern ssize_t wlp_dev_prim_category_show(struct wlp *, char *); | |
701 | extern ssize_t wlp_dev_prim_category_store(struct wlp *, const char *, | |
702 | size_t); | |
703 | extern ssize_t wlp_dev_prim_OUI_show(struct wlp *, char *); | |
704 | extern ssize_t wlp_dev_prim_OUI_store(struct wlp *, const char *, size_t); | |
705 | extern ssize_t wlp_dev_prim_OUI_sub_show(struct wlp *, char *); | |
706 | extern ssize_t wlp_dev_prim_OUI_sub_store(struct wlp *, const char *, | |
707 | size_t); | |
708 | extern ssize_t wlp_dev_prim_subcat_show(struct wlp *, char *); | |
709 | extern ssize_t wlp_dev_prim_subcat_store(struct wlp *, const char *, | |
710 | size_t); | |
711 | extern int wlp_receive_frame(struct device *, struct wlp *, struct sk_buff *, | |
712 | struct uwb_dev_addr *); | |
713 | extern int wlp_prepare_tx_frame(struct device *, struct wlp *, | |
714 | struct sk_buff *, struct uwb_dev_addr *); | |
715 | void wlp_reset_all(struct wlp *wlp); | |
716 | ||
717 | /** | |
718 | * Initialize WSS | |
719 | */ | |
720 | static inline | |
721 | void wlp_wss_init(struct wlp_wss *wss) | |
722 | { | |
723 | mutex_init(&wss->mutex); | |
724 | } | |
725 | ||
726 | static inline | |
727 | void wlp_init(struct wlp *wlp) | |
728 | { | |
729 | INIT_LIST_HEAD(&wlp->neighbors); | |
730 | mutex_init(&wlp->mutex); | |
731 | mutex_init(&wlp->nbmutex); | |
732 | wlp_wss_init(&wlp->wss); | |
733 | } | |
734 | ||
735 | ||
736 | #endif /* #ifndef __LINUX__WLP_H_ */ |