drivers/uwb/wlp/wss-lc.c

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