aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/uwb/wlp/wss-lc.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/uwb/wlp/wss-lc.c')
-rw-r--r--drivers/uwb/wlp/wss-lc.c959
1 files changed, 0 insertions, 959 deletions
diff --git a/drivers/uwb/wlp/wss-lc.c b/drivers/uwb/wlp/wss-lc.c
deleted file mode 100644
index 67872c83b679..000000000000
--- a/drivers/uwb/wlp/wss-lc.c
+++ /dev/null
@@ -1,959 +0,0 @@
1/*
2 * WiMedia Logical Link Control Protocol (WLP)
3 *
4 * Copyright (C) 2007 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 * Implementation of the WLP association protocol.
23 *
24 * FIXME: Docs
25 *
26 * A UWB network interface will configure a WSS through wlp_wss_setup() after
27 * the interface has been assigned a MAC address, typically after
28 * "ifconfig" has been called. When the interface goes down it should call
29 * wlp_wss_remove().
30 *
31 * When the WSS is ready for use the user interacts via sysfs to create,
32 * discover, and activate WSS.
33 *
34 * wlp_wss_enroll_activate()
35 *
36 * wlp_wss_create_activate()
37 * wlp_wss_set_wssid_hash()
38 * wlp_wss_comp_wssid_hash()
39 * wlp_wss_sel_bcast_addr()
40 * wlp_wss_sysfs_add()
41 *
42 * Called when no more references to WSS exist:
43 * wlp_wss_release()
44 * wlp_wss_reset()
45 */
46#include <linux/etherdevice.h> /* for is_valid_ether_addr */
47#include <linux/skbuff.h>
48#include <linux/slab.h>
49#include <linux/wlp.h>
50
51#include "wlp-internal.h"
52
53size_t wlp_wss_key_print(char *buf, size_t bufsize, u8 *key)
54{
55 size_t result;
56
57 result = scnprintf(buf, bufsize,
58 "%02x %02x %02x %02x %02x %02x "
59 "%02x %02x %02x %02x %02x %02x "
60 "%02x %02x %02x %02x",
61 key[0], key[1], key[2], key[3],
62 key[4], key[5], key[6], key[7],
63 key[8], key[9], key[10], key[11],
64 key[12], key[13], key[14], key[15]);
65 return result;
66}
67
68/**
69 * Compute WSSID hash
70 * WLP Draft 0.99 [7.2.1]
71 *
72 * The WSSID hash for a WSSID is the result of an octet-wise exclusive-OR
73 * of all octets in the WSSID.
74 */
75static
76u8 wlp_wss_comp_wssid_hash(struct wlp_uuid *wssid)
77{
78 return wssid->data[0] ^ wssid->data[1] ^ wssid->data[2]
79 ^ wssid->data[3] ^ wssid->data[4] ^ wssid->data[5]
80 ^ wssid->data[6] ^ wssid->data[7] ^ wssid->data[8]
81 ^ wssid->data[9] ^ wssid->data[10] ^ wssid->data[11]
82 ^ wssid->data[12] ^ wssid->data[13] ^ wssid->data[14]
83 ^ wssid->data[15];
84}
85
86/**
87 * Select a multicast EUI-48 for the WSS broadcast address.
88 * WLP Draft 0.99 [7.2.1]
89 *
90 * Selected based on the WiMedia Alliance OUI, 00-13-88, within the WLP
91 * range, [01-13-88-00-01-00, 01-13-88-00-01-FF] inclusive.
92 *
93 * This address is currently hardcoded.
94 * FIXME?
95 */
96static
97struct uwb_mac_addr wlp_wss_sel_bcast_addr(struct wlp_wss *wss)
98{
99 struct uwb_mac_addr bcast = {
100 .data = { 0x01, 0x13, 0x88, 0x00, 0x01, 0x00 }
101 };
102 return bcast;
103}
104
105/**
106 * Clear the contents of the WSS structure - all except kobj, mutex, virtual
107 *
108 * We do not want to reinitialize - the internal kobj should not change as
109 * it still points to the parent received during setup. The mutex should
110 * remain also. We thus just reset values individually.
111 * The virutal address assigned to WSS will remain the same for the
112 * lifetime of the WSS. We only reset the fields that can change during its
113 * lifetime.
114 */
115void wlp_wss_reset(struct wlp_wss *wss)
116{
117 memset(&wss->wssid, 0, sizeof(wss->wssid));
118 wss->hash = 0;
119 memset(&wss->name[0], 0, sizeof(wss->name));
120 memset(&wss->bcast, 0, sizeof(wss->bcast));
121 wss->secure_status = WLP_WSS_UNSECURE;
122 memset(&wss->master_key[0], 0, sizeof(wss->master_key));
123 wss->tag = 0;
124 wss->state = WLP_WSS_STATE_NONE;
125}
126
127/**
128 * Create sysfs infrastructure for WSS
129 *
130 * The WSS is configured to have the interface as parent (see wlp_wss_setup())
131 * a new sysfs directory that includes wssid as its name is created in the
132 * interface's sysfs directory. The group of files interacting with WSS are
133 * created also.
134 */
135static
136int wlp_wss_sysfs_add(struct wlp_wss *wss, char *wssid_str)
137{
138 struct wlp *wlp = container_of(wss, struct wlp, wss);
139 struct device *dev = &wlp->rc->uwb_dev.dev;
140 int result;
141
142 result = kobject_set_name(&wss->kobj, "wss-%s", wssid_str);
143 if (result < 0)
144 return result;
145 wss->kobj.ktype = &wss_ktype;
146 result = kobject_init_and_add(&wss->kobj,
147 &wss_ktype, wss->kobj.parent, "wlp");
148 if (result < 0) {
149 dev_err(dev, "WLP: Cannot register WSS kobject.\n");
150 goto error_kobject_register;
151 }
152 result = sysfs_create_group(&wss->kobj, &wss_attr_group);
153 if (result < 0) {
154 dev_err(dev, "WLP: Cannot register WSS attributes: %d\n",
155 result);
156 goto error_sysfs_create_group;
157 }
158 return 0;
159error_sysfs_create_group:
160
161 kobject_put(&wss->kobj); /* will free name if needed */
162 return result;
163error_kobject_register:
164 kfree(wss->kobj.name);
165 wss->kobj.name = NULL;
166 wss->kobj.ktype = NULL;
167 return result;
168}
169
170
171/**
172 * Release WSS
173 *
174 * No more references exist to this WSS. We should undo everything that was
175 * done in wlp_wss_create_activate() except removing the group. The group
176 * is not removed because an object can be unregistered before the group is
177 * created. We also undo any additional operations on the WSS after this
178 * (addition of members).
179 *
180 * If memory was allocated for the kobject's name then it will
181 * be freed by the kobject system during this time.
182 *
183 * The EDA cache is removed and reinitialized when the WSS is removed. We
184 * thus loose knowledge of members of this WSS at that time and need not do
185 * it here.
186 */
187void wlp_wss_release(struct kobject *kobj)
188{
189 struct wlp_wss *wss = container_of(kobj, struct wlp_wss, kobj);
190
191 wlp_wss_reset(wss);
192}
193
194/**
195 * Enroll into a WSS using provided neighbor as registrar
196 *
197 * First search the neighborhood information to learn which neighbor is
198 * referred to, next proceed with enrollment.
199 *
200 * &wss->mutex is held
201 */
202static
203int wlp_wss_enroll_target(struct wlp_wss *wss, struct wlp_uuid *wssid,
204 struct uwb_dev_addr *dest)
205{
206 struct wlp *wlp = container_of(wss, struct wlp, wss);
207 struct device *dev = &wlp->rc->uwb_dev.dev;
208 struct wlp_neighbor_e *neighbor;
209 int result = -ENXIO;
210 struct uwb_dev_addr *dev_addr;
211
212 mutex_lock(&wlp->nbmutex);
213 list_for_each_entry(neighbor, &wlp->neighbors, node) {
214 dev_addr = &neighbor->uwb_dev->dev_addr;
215 if (!memcmp(dest, dev_addr, sizeof(*dest))) {
216 result = wlp_enroll_neighbor(wlp, neighbor, wss, wssid);
217 break;
218 }
219 }
220 if (result == -ENXIO)
221 dev_err(dev, "WLP: Cannot find neighbor %02x:%02x. \n",
222 dest->data[1], dest->data[0]);
223 mutex_unlock(&wlp->nbmutex);
224 return result;
225}
226
227/**
228 * Enroll into a WSS previously discovered
229 *
230 * User provides WSSID of WSS, search for neighbor that has this WSS
231 * activated and attempt to enroll.
232 *
233 * &wss->mutex is held
234 */
235static
236int wlp_wss_enroll_discovered(struct wlp_wss *wss, struct wlp_uuid *wssid)
237{
238 struct wlp *wlp = container_of(wss, struct wlp, wss);
239 struct device *dev = &wlp->rc->uwb_dev.dev;
240 struct wlp_neighbor_e *neighbor;
241 struct wlp_wssid_e *wssid_e;
242 char buf[WLP_WSS_UUID_STRSIZE];
243 int result = -ENXIO;
244
245
246 mutex_lock(&wlp->nbmutex);
247 list_for_each_entry(neighbor, &wlp->neighbors, node) {
248 list_for_each_entry(wssid_e, &neighbor->wssid, node) {
249 if (!memcmp(wssid, &wssid_e->wssid, sizeof(*wssid))) {
250 result = wlp_enroll_neighbor(wlp, neighbor,
251 wss, wssid);
252 if (result == 0) /* enrollment success */
253 goto out;
254 break;
255 }
256 }
257 }
258out:
259 if (result == -ENXIO) {
260 wlp_wss_uuid_print(buf, sizeof(buf), wssid);
261 dev_err(dev, "WLP: Cannot find WSSID %s in cache. \n", buf);
262 }
263 mutex_unlock(&wlp->nbmutex);
264 return result;
265}
266
267/**
268 * Enroll into WSS with provided WSSID, registrar may be provided
269 *
270 * @wss: out WSS that will be enrolled
271 * @wssid: wssid of neighboring WSS that we want to enroll in
272 * @devaddr: registrar can be specified, will be broadcast (ff:ff) if any
273 * neighbor can be used as registrar.
274 *
275 * &wss->mutex is held
276 */
277static
278int wlp_wss_enroll(struct wlp_wss *wss, struct wlp_uuid *wssid,
279 struct uwb_dev_addr *devaddr)
280{
281 int result;
282 struct wlp *wlp = container_of(wss, struct wlp, wss);
283 struct device *dev = &wlp->rc->uwb_dev.dev;
284 char buf[WLP_WSS_UUID_STRSIZE];
285 struct uwb_dev_addr bcast = {.data = {0xff, 0xff} };
286
287 wlp_wss_uuid_print(buf, sizeof(buf), wssid);
288
289 if (wss->state != WLP_WSS_STATE_NONE) {
290 dev_err(dev, "WLP: Already enrolled in WSS %s.\n", buf);
291 result = -EEXIST;
292 goto error;
293 }
294 if (!memcmp(&bcast, devaddr, sizeof(bcast)))
295 result = wlp_wss_enroll_discovered(wss, wssid);
296 else
297 result = wlp_wss_enroll_target(wss, wssid, devaddr);
298 if (result < 0) {
299 dev_err(dev, "WLP: Unable to enroll into WSS %s, result %d \n",
300 buf, result);
301 goto error;
302 }
303 dev_dbg(dev, "Successfully enrolled into WSS %s \n", buf);
304 result = wlp_wss_sysfs_add(wss, buf);
305 if (result < 0) {
306 dev_err(dev, "WLP: Unable to set up sysfs for WSS kobject.\n");
307 wlp_wss_reset(wss);
308 }
309error:
310 return result;
311
312}
313
314/**
315 * Activate given WSS
316 *
317 * Prior to activation a WSS must be enrolled. To activate a WSS a device
318 * includes the WSS hash in the WLP IE in its beacon in each superframe.
319 * WLP 0.99 [7.2.5].
320 *
321 * The WSS tag is also computed at this time. We only support one activated
322 * WSS so we can use the hash as a tag - there will never be a conflict.
323 *
324 * We currently only support one activated WSS so only one WSS hash is
325 * included in the WLP IE.
326 */
327static
328int wlp_wss_activate(struct wlp_wss *wss)
329{
330 struct wlp *wlp = container_of(wss, struct wlp, wss);
331 struct device *dev = &wlp->rc->uwb_dev.dev;
332 struct uwb_rc *uwb_rc = wlp->rc;
333 int result;
334 struct {
335 struct wlp_ie wlp_ie;
336 u8 hash; /* only include one hash */
337 } ie_data;
338
339 BUG_ON(wss->state != WLP_WSS_STATE_ENROLLED);
340 wss->hash = wlp_wss_comp_wssid_hash(&wss->wssid);
341 wss->tag = wss->hash;
342 memset(&ie_data, 0, sizeof(ie_data));
343 ie_data.wlp_ie.hdr.element_id = UWB_IE_WLP;
344 ie_data.wlp_ie.hdr.length = sizeof(ie_data) - sizeof(struct uwb_ie_hdr);
345 wlp_ie_set_hash_length(&ie_data.wlp_ie, sizeof(ie_data.hash));
346 ie_data.hash = wss->hash;
347 result = uwb_rc_ie_add(uwb_rc, &ie_data.wlp_ie.hdr,
348 sizeof(ie_data));
349 if (result < 0) {
350 dev_err(dev, "WLP: Unable to add WLP IE to beacon. "
351 "result = %d.\n", result);
352 goto error_wlp_ie;
353 }
354 wss->state = WLP_WSS_STATE_ACTIVE;
355 result = 0;
356error_wlp_ie:
357 return result;
358}
359
360/**
361 * Enroll in and activate WSS identified by provided WSSID
362 *
363 * The neighborhood cache should contain a list of all neighbors and the
364 * WSS they have activated. Based on that cache we search which neighbor we
365 * can perform the association process with. The user also has option to
366 * specify which neighbor it prefers as registrar.
367 * Successful enrollment is followed by activation.
368 * Successful activation will create the sysfs directory containing
369 * specific information regarding this WSS.
370 */
371int wlp_wss_enroll_activate(struct wlp_wss *wss, struct wlp_uuid *wssid,
372 struct uwb_dev_addr *devaddr)
373{
374 struct wlp *wlp = container_of(wss, struct wlp, wss);
375 struct device *dev = &wlp->rc->uwb_dev.dev;
376 int result = 0;
377 char buf[WLP_WSS_UUID_STRSIZE];
378
379 mutex_lock(&wss->mutex);
380 result = wlp_wss_enroll(wss, wssid, devaddr);
381 if (result < 0) {
382 wlp_wss_uuid_print(buf, sizeof(buf), &wss->wssid);
383 dev_err(dev, "WLP: Enrollment into WSS %s failed.\n", buf);
384 goto error_enroll;
385 }
386 result = wlp_wss_activate(wss);
387 if (result < 0) {
388 dev_err(dev, "WLP: Unable to activate WSS. Undoing enrollment "
389 "result = %d \n", result);
390 /* Undo enrollment */
391 wlp_wss_reset(wss);
392 goto error_activate;
393 }
394error_activate:
395error_enroll:
396 mutex_unlock(&wss->mutex);
397 return result;
398}
399
400/**
401 * Create, enroll, and activate a new WSS
402 *
403 * @wssid: new wssid provided by user
404 * @name: WSS name requested by used.
405 * @sec_status: security status requested by user
406 *
407 * A user requested the creation of a new WSS. All operations are done
408 * locally. The new WSS will be stored locally, the hash will be included
409 * in the WLP IE, and the sysfs infrastructure for this WSS will be
410 * created.
411 */
412int wlp_wss_create_activate(struct wlp_wss *wss, struct wlp_uuid *wssid,
413 char *name, unsigned sec_status, unsigned accept)
414{
415 struct wlp *wlp = container_of(wss, struct wlp, wss);
416 struct device *dev = &wlp->rc->uwb_dev.dev;
417 int result = 0;
418 char buf[WLP_WSS_UUID_STRSIZE];
419
420 result = wlp_wss_uuid_print(buf, sizeof(buf), wssid);
421
422 if (!mutex_trylock(&wss->mutex)) {
423 dev_err(dev, "WLP: WLP association session in progress.\n");
424 return -EBUSY;
425 }
426 if (wss->state != WLP_WSS_STATE_NONE) {
427 dev_err(dev, "WLP: WSS already exists. Not creating new.\n");
428 result = -EEXIST;
429 goto out;
430 }
431 if (wss->kobj.parent == NULL) {
432 dev_err(dev, "WLP: WSS parent not ready. Is network interface "
433 "up?\n");
434 result = -ENXIO;
435 goto out;
436 }
437 if (sec_status == WLP_WSS_SECURE) {
438 dev_err(dev, "WLP: FIXME Creation of secure WSS not "
439 "supported yet.\n");
440 result = -EINVAL;
441 goto out;
442 }
443 wss->wssid = *wssid;
444 memcpy(wss->name, name, sizeof(wss->name));
445 wss->bcast = wlp_wss_sel_bcast_addr(wss);
446 wss->secure_status = sec_status;
447 wss->accept_enroll = accept;
448 /*wss->virtual_addr is initialized in call to wlp_wss_setup*/
449 /* sysfs infrastructure */
450 result = wlp_wss_sysfs_add(wss, buf);
451 if (result < 0) {
452 dev_err(dev, "Cannot set up sysfs for WSS kobject.\n");
453 wlp_wss_reset(wss);
454 goto out;
455 } else
456 result = 0;
457 wss->state = WLP_WSS_STATE_ENROLLED;
458 result = wlp_wss_activate(wss);
459 if (result < 0) {
460 dev_err(dev, "WLP: Unable to activate WSS. Undoing "
461 "enrollment\n");
462 wlp_wss_reset(wss);
463 goto out;
464 }
465 result = 0;
466out:
467 mutex_unlock(&wss->mutex);
468 return result;
469}
470
471/**
472 * Determine if neighbor has WSS activated
473 *
474 * @returns: 1 if neighbor has WSS activated, zero otherwise
475 *
476 * This can be done in two ways:
477 * - send a C1 frame, parse C2/F0 response
478 * - examine the WLP IE sent by the neighbor
479 *
480 * The WLP IE is not fully supported in hardware so we use the C1/C2 frame
481 * exchange to determine if a WSS is activated. Using the WLP IE should be
482 * faster and should be used when it becomes possible.
483 */
484int wlp_wss_is_active(struct wlp *wlp, struct wlp_wss *wss,
485 struct uwb_dev_addr *dev_addr)
486{
487 int result = 0;
488 struct device *dev = &wlp->rc->uwb_dev.dev;
489 DECLARE_COMPLETION_ONSTACK(completion);
490 struct wlp_session session;
491 struct sk_buff *skb;
492 struct wlp_frame_assoc *resp;
493 struct wlp_uuid wssid;
494
495 mutex_lock(&wlp->mutex);
496 /* Send C1 association frame */
497 result = wlp_send_assoc_frame(wlp, wss, dev_addr, WLP_ASSOC_C1);
498 if (result < 0) {
499 dev_err(dev, "Unable to send C1 frame to neighbor "
500 "%02x:%02x (%d)\n", dev_addr->data[1],
501 dev_addr->data[0], result);
502 result = 0;
503 goto out;
504 }
505 /* Create session, wait for response */
506 session.exp_message = WLP_ASSOC_C2;
507 session.cb = wlp_session_cb;
508 session.cb_priv = &completion;
509 session.neighbor_addr = *dev_addr;
510 BUG_ON(wlp->session != NULL);
511 wlp->session = &session;
512 /* Wait for C2/F0 frame */
513 result = wait_for_completion_interruptible_timeout(&completion,
514 WLP_PER_MSG_TIMEOUT * HZ);
515 if (result == 0) {
516 dev_err(dev, "Timeout while sending C1 to neighbor "
517 "%02x:%02x.\n", dev_addr->data[1],
518 dev_addr->data[0]);
519 goto out;
520 }
521 if (result < 0) {
522 dev_err(dev, "Unable to send C1 to neighbor %02x:%02x.\n",
523 dev_addr->data[1], dev_addr->data[0]);
524 result = 0;
525 goto out;
526 }
527 /* Parse message in session->data: it will be either C2 or F0 */
528 skb = session.data;
529 resp = (void *) skb->data;
530 if (resp->type == WLP_ASSOC_F0) {
531 result = wlp_parse_f0(wlp, skb);
532 if (result < 0)
533 dev_err(dev, "WLP: unable to parse incoming F0 "
534 "frame from neighbor %02x:%02x.\n",
535 dev_addr->data[1], dev_addr->data[0]);
536 result = 0;
537 goto error_resp_parse;
538 }
539 /* WLP version and message type fields have already been parsed */
540 result = wlp_get_wssid(wlp, (void *)resp + sizeof(*resp), &wssid,
541 skb->len - sizeof(*resp));
542 if (result < 0) {
543 dev_err(dev, "WLP: unable to obtain WSSID from C2 frame.\n");
544 result = 0;
545 goto error_resp_parse;
546 }
547 if (!memcmp(&wssid, &wss->wssid, sizeof(wssid)))
548 result = 1;
549 else {
550 dev_err(dev, "WLP: Received a C2 frame without matching "
551 "WSSID.\n");
552 result = 0;
553 }
554error_resp_parse:
555 kfree_skb(skb);
556out:
557 wlp->session = NULL;
558 mutex_unlock(&wlp->mutex);
559 return result;
560}
561
562/**
563 * Activate connection with neighbor by updating EDA cache
564 *
565 * @wss: local WSS to which neighbor wants to connect
566 * @dev_addr: neighbor's address
567 * @wssid: neighbor's WSSID - must be same as our WSS's WSSID
568 * @tag: neighbor's WSS tag used to identify frames transmitted by it
569 * @virt_addr: neighbor's virtual EUI-48
570 */
571static
572int wlp_wss_activate_connection(struct wlp *wlp, struct wlp_wss *wss,
573 struct uwb_dev_addr *dev_addr,
574 struct wlp_uuid *wssid, u8 *tag,
575 struct uwb_mac_addr *virt_addr)
576{
577 struct device *dev = &wlp->rc->uwb_dev.dev;
578 int result = 0;
579
580 if (!memcmp(wssid, &wss->wssid, sizeof(*wssid))) {
581 /* Update EDA cache */
582 result = wlp_eda_update_node(&wlp->eda, dev_addr, wss,
583 (void *) virt_addr->data, *tag,
584 WLP_WSS_CONNECTED);
585 if (result < 0)
586 dev_err(dev, "WLP: Unable to update EDA cache "
587 "with new connected neighbor information.\n");
588 } else {
589 dev_err(dev, "WLP: Neighbor does not have matching WSSID.\n");
590 result = -EINVAL;
591 }
592 return result;
593}
594
595/**
596 * Connect to WSS neighbor
597 *
598 * Use C3/C4 exchange to determine if neighbor has WSS activated and
599 * retrieve the WSS tag and virtual EUI-48 of the neighbor.
600 */
601static
602int wlp_wss_connect_neighbor(struct wlp *wlp, struct wlp_wss *wss,
603 struct uwb_dev_addr *dev_addr)
604{
605 int result;
606 struct device *dev = &wlp->rc->uwb_dev.dev;
607 struct wlp_uuid wssid;
608 u8 tag;
609 struct uwb_mac_addr virt_addr;
610 DECLARE_COMPLETION_ONSTACK(completion);
611 struct wlp_session session;
612 struct wlp_frame_assoc *resp;
613 struct sk_buff *skb;
614
615 mutex_lock(&wlp->mutex);
616 /* Send C3 association frame */
617 result = wlp_send_assoc_frame(wlp, wss, dev_addr, WLP_ASSOC_C3);
618 if (result < 0) {
619 dev_err(dev, "Unable to send C3 frame to neighbor "
620 "%02x:%02x (%d)\n", dev_addr->data[1],
621 dev_addr->data[0], result);
622 goto out;
623 }
624 /* Create session, wait for response */
625 session.exp_message = WLP_ASSOC_C4;
626 session.cb = wlp_session_cb;
627 session.cb_priv = &completion;
628 session.neighbor_addr = *dev_addr;
629 BUG_ON(wlp->session != NULL);
630 wlp->session = &session;
631 /* Wait for C4/F0 frame */
632 result = wait_for_completion_interruptible_timeout(&completion,
633 WLP_PER_MSG_TIMEOUT * HZ);
634 if (result == 0) {
635 dev_err(dev, "Timeout while sending C3 to neighbor "
636 "%02x:%02x.\n", dev_addr->data[1],
637 dev_addr->data[0]);
638 result = -ETIMEDOUT;
639 goto out;
640 }
641 if (result < 0) {
642 dev_err(dev, "Unable to send C3 to neighbor %02x:%02x.\n",
643 dev_addr->data[1], dev_addr->data[0]);
644 goto out;
645 }
646 /* Parse message in session->data: it will be either C4 or F0 */
647 skb = session.data;
648 resp = (void *) skb->data;
649 if (resp->type == WLP_ASSOC_F0) {
650 result = wlp_parse_f0(wlp, skb);
651 if (result < 0)
652 dev_err(dev, "WLP: unable to parse incoming F0 "
653 "frame from neighbor %02x:%02x.\n",
654 dev_addr->data[1], dev_addr->data[0]);
655 result = -EINVAL;
656 goto error_resp_parse;
657 }
658 result = wlp_parse_c3c4_frame(wlp, skb, &wssid, &tag, &virt_addr);
659 if (result < 0) {
660 dev_err(dev, "WLP: Unable to parse C4 frame from neighbor.\n");
661 goto error_resp_parse;
662 }
663 result = wlp_wss_activate_connection(wlp, wss, dev_addr, &wssid, &tag,
664 &virt_addr);
665 if (result < 0) {
666 dev_err(dev, "WLP: Unable to activate connection to "
667 "neighbor %02x:%02x.\n", dev_addr->data[1],
668 dev_addr->data[0]);
669 goto error_resp_parse;
670 }
671error_resp_parse:
672 kfree_skb(skb);
673out:
674 /* Record that we unsuccessfully tried to connect to this neighbor */
675 if (result < 0)
676 wlp_eda_update_node_state(&wlp->eda, dev_addr,
677 WLP_WSS_CONNECT_FAILED);
678 wlp->session = NULL;
679 mutex_unlock(&wlp->mutex);
680 return result;
681}
682
683/**
684 * Connect to neighbor with common WSS, send pending frame
685 *
686 * This function is scheduled when a frame is destined to a neighbor with
687 * which we do not have a connection. A copy of the EDA cache entry is
688 * provided - not the actual cache entry (because it is protected by a
689 * spinlock).
690 *
691 * First determine if neighbor has the same WSS activated, connect if it
692 * does. The C3/C4 exchange is dual purpose to determine if neighbor has
693 * WSS activated and proceed with the connection.
694 *
695 * The frame that triggered the connection setup is sent after connection
696 * setup.
697 *
698 * network queue is stopped - we need to restart when done
699 *
700 */
701static
702void wlp_wss_connect_send(struct work_struct *ws)
703{
704 struct wlp_assoc_conn_ctx *conn_ctx = container_of(ws,
705 struct wlp_assoc_conn_ctx,
706 ws);
707 struct wlp *wlp = conn_ctx->wlp;
708 struct sk_buff *skb = conn_ctx->skb;
709 struct wlp_eda_node *eda_entry = &conn_ctx->eda_entry;
710 struct uwb_dev_addr *dev_addr = &eda_entry->dev_addr;
711 struct wlp_wss *wss = &wlp->wss;
712 int result;
713 struct device *dev = &wlp->rc->uwb_dev.dev;
714
715 mutex_lock(&wss->mutex);
716 if (wss->state < WLP_WSS_STATE_ACTIVE) {
717 if (printk_ratelimit())
718 dev_err(dev, "WLP: Attempting to connect with "
719 "WSS that is not active or connected.\n");
720 dev_kfree_skb(skb);
721 goto out;
722 }
723 /* Establish connection - send C3 rcv C4 */
724 result = wlp_wss_connect_neighbor(wlp, wss, dev_addr);
725 if (result < 0) {
726 if (printk_ratelimit())
727 dev_err(dev, "WLP: Unable to establish connection "
728 "with neighbor %02x:%02x.\n",
729 dev_addr->data[1], dev_addr->data[0]);
730 dev_kfree_skb(skb);
731 goto out;
732 }
733 /* EDA entry changed, update the local copy being used */
734 result = wlp_copy_eda_node(&wlp->eda, dev_addr, eda_entry);
735 if (result < 0) {
736 if (printk_ratelimit())
737 dev_err(dev, "WLP: Cannot find EDA entry for "
738 "neighbor %02x:%02x \n",
739 dev_addr->data[1], dev_addr->data[0]);
740 }
741 result = wlp_wss_prep_hdr(wlp, eda_entry, skb);
742 if (result < 0) {
743 if (printk_ratelimit())
744 dev_err(dev, "WLP: Unable to prepare frame header for "
745 "transmission (neighbor %02x:%02x). \n",
746 dev_addr->data[1], dev_addr->data[0]);
747 dev_kfree_skb(skb);
748 goto out;
749 }
750 BUG_ON(wlp->xmit_frame == NULL);
751 result = wlp->xmit_frame(wlp, skb, dev_addr);
752 if (result < 0) {
753 if (printk_ratelimit())
754 dev_err(dev, "WLP: Unable to transmit frame: %d\n",
755 result);
756 if (result == -ENXIO)
757 dev_err(dev, "WLP: Is network interface up? \n");
758 /* We could try again ... */
759 dev_kfree_skb(skb);/*we need to free if tx fails */
760 }
761out:
762 kfree(conn_ctx);
763 BUG_ON(wlp->start_queue == NULL);
764 wlp->start_queue(wlp);
765 mutex_unlock(&wss->mutex);
766}
767
768/**
769 * Add WLP header to outgoing skb
770 *
771 * @eda_entry: pointer to neighbor's entry in the EDA cache
772 * @_skb: skb containing data destined to the neighbor
773 */
774int wlp_wss_prep_hdr(struct wlp *wlp, struct wlp_eda_node *eda_entry,
775 void *_skb)
776{
777 struct device *dev = &wlp->rc->uwb_dev.dev;
778 int result = 0;
779 unsigned char *eth_addr = eda_entry->eth_addr;
780 struct uwb_dev_addr *dev_addr = &eda_entry->dev_addr;
781 struct sk_buff *skb = _skb;
782 struct wlp_frame_std_abbrv_hdr *std_hdr;
783
784 if (eda_entry->state == WLP_WSS_CONNECTED) {
785 /* Add WLP header */
786 BUG_ON(skb_headroom(skb) < sizeof(*std_hdr));
787 std_hdr = (void *) __skb_push(skb, sizeof(*std_hdr));
788 std_hdr->hdr.mux_hdr = cpu_to_le16(WLP_PROTOCOL_ID);
789 std_hdr->hdr.type = WLP_FRAME_STANDARD;
790 std_hdr->tag = eda_entry->wss->tag;
791 } else {
792 if (printk_ratelimit())
793 dev_err(dev, "WLP: Destination neighbor (Ethernet: "
794 "%pM, Dev: %02x:%02x) is not connected.\n",
795 eth_addr, dev_addr->data[1], dev_addr->data[0]);
796 result = -EINVAL;
797 }
798 return result;
799}
800
801
802/**
803 * Prepare skb for neighbor: connect if not already and prep WLP header
804 *
805 * This function is called in interrupt context, but it needs to sleep. We
806 * temporarily stop the net queue to establish the WLP connection.
807 * Setup of the WLP connection and restart of queue is scheduled
808 * on the default work queue.
809 *
810 * run with eda->lock held (spinlock)
811 */
812int wlp_wss_connect_prep(struct wlp *wlp, struct wlp_eda_node *eda_entry,
813 void *_skb)
814{
815 int result = 0;
816 struct device *dev = &wlp->rc->uwb_dev.dev;
817 struct sk_buff *skb = _skb;
818 struct wlp_assoc_conn_ctx *conn_ctx;
819
820 if (eda_entry->state == WLP_WSS_UNCONNECTED) {
821 /* We don't want any more packets while we set up connection */
822 BUG_ON(wlp->stop_queue == NULL);
823 wlp->stop_queue(wlp);
824 conn_ctx = kmalloc(sizeof(*conn_ctx), GFP_ATOMIC);
825 if (conn_ctx == NULL) {
826 if (printk_ratelimit())
827 dev_err(dev, "WLP: Unable to allocate memory "
828 "for connection handling.\n");
829 result = -ENOMEM;
830 goto out;
831 }
832 conn_ctx->wlp = wlp;
833 conn_ctx->skb = skb;
834 conn_ctx->eda_entry = *eda_entry;
835 INIT_WORK(&conn_ctx->ws, wlp_wss_connect_send);
836 schedule_work(&conn_ctx->ws);
837 result = 1;
838 } else if (eda_entry->state == WLP_WSS_CONNECT_FAILED) {
839 /* Previous connection attempts failed, don't retry - see
840 * conditions for connection in WLP 0.99 [7.6.2] */
841 if (printk_ratelimit())
842 dev_err(dev, "Could not connect to neighbor "
843 "previously. Not retrying. \n");
844 result = -ENONET;
845 goto out;
846 } else /* eda_entry->state == WLP_WSS_CONNECTED */
847 result = wlp_wss_prep_hdr(wlp, eda_entry, skb);
848out:
849 return result;
850}
851
852/**
853 * Emulate broadcast: copy skb, send copy to neighbor (connect if not already)
854 *
855 * We need to copy skbs in the case where we emulate broadcast through
856 * unicast. We copy instead of clone because we are modifying the data of
857 * the frame after copying ... clones share data so we cannot emulate
858 * broadcast using clones.
859 *
860 * run with eda->lock held (spinlock)
861 */
862int wlp_wss_send_copy(struct wlp *wlp, struct wlp_eda_node *eda_entry,
863 void *_skb)
864{
865 int result = -ENOMEM;
866 struct device *dev = &wlp->rc->uwb_dev.dev;
867 struct sk_buff *skb = _skb;
868 struct sk_buff *copy;
869 struct uwb_dev_addr *dev_addr = &eda_entry->dev_addr;
870
871 copy = skb_copy(skb, GFP_ATOMIC);
872 if (copy == NULL) {
873 if (printk_ratelimit())
874 dev_err(dev, "WLP: Unable to copy skb for "
875 "transmission.\n");
876 goto out;
877 }
878 result = wlp_wss_connect_prep(wlp, eda_entry, copy);
879 if (result < 0) {
880 if (printk_ratelimit())
881 dev_err(dev, "WLP: Unable to connect/send skb "
882 "to neighbor.\n");
883 dev_kfree_skb_irq(copy);
884 goto out;
885 } else if (result == 1)
886 /* Frame will be transmitted separately */
887 goto out;
888 BUG_ON(wlp->xmit_frame == NULL);
889 result = wlp->xmit_frame(wlp, copy, dev_addr);
890 if (result < 0) {
891 if (printk_ratelimit())
892 dev_err(dev, "WLP: Unable to transmit frame: %d\n",
893 result);
894 if ((result == -ENXIO) && printk_ratelimit())
895 dev_err(dev, "WLP: Is network interface up? \n");
896 /* We could try again ... */
897 dev_kfree_skb_irq(copy);/*we need to free if tx fails */
898 }
899out:
900 return result;
901}
902
903
904/**
905 * Setup WSS
906 *
907 * Should be called by network driver after the interface has been given a
908 * MAC address.
909 */
910int wlp_wss_setup(struct net_device *net_dev, struct wlp_wss *wss)
911{
912 struct wlp *wlp = container_of(wss, struct wlp, wss);
913 struct device *dev = &wlp->rc->uwb_dev.dev;
914 int result = 0;
915
916 mutex_lock(&wss->mutex);
917 wss->kobj.parent = &net_dev->dev.kobj;
918 if (!is_valid_ether_addr(net_dev->dev_addr)) {
919 dev_err(dev, "WLP: Invalid MAC address. Cannot use for"
920 "virtual.\n");
921 result = -EINVAL;
922 goto out;
923 }
924 memcpy(wss->virtual_addr.data, net_dev->dev_addr,
925 sizeof(wss->virtual_addr.data));
926out:
927 mutex_unlock(&wss->mutex);
928 return result;
929}
930EXPORT_SYMBOL_GPL(wlp_wss_setup);
931
932/**
933 * Remove WSS
934 *
935 * Called by client that configured WSS through wlp_wss_setup(). This
936 * function is called when client no longer needs WSS, eg. client shuts
937 * down.
938 *
939 * We remove the WLP IE from the beacon before initiating local cleanup.
940 */
941void wlp_wss_remove(struct wlp_wss *wss)
942{
943 struct wlp *wlp = container_of(wss, struct wlp, wss);
944
945 mutex_lock(&wss->mutex);
946 if (wss->state == WLP_WSS_STATE_ACTIVE)
947 uwb_rc_ie_rm(wlp->rc, UWB_IE_WLP);
948 if (wss->state != WLP_WSS_STATE_NONE) {
949 sysfs_remove_group(&wss->kobj, &wss_attr_group);
950 kobject_put(&wss->kobj);
951 }
952 wss->kobj.parent = NULL;
953 memset(&wss->virtual_addr, 0, sizeof(wss->virtual_addr));
954 /* Cleanup EDA cache */
955 wlp_eda_release(&wlp->eda);
956 wlp_eda_init(&wlp->eda);
957 mutex_unlock(&wss->mutex);
958}
959EXPORT_SYMBOL_GPL(wlp_wss_remove);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-22 06:54:12 -0500