drivers/uwb/lc-rc.c

   1 /*
   2  * Ultra Wide Band
   3  * Life cycle of radio controllers
   4  *
   5  * Copyright (C) 2005-2006 Intel Corporation
   6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version
  10  * 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA.
  21  *
  22  *
  23  * FIXME: docs
  24  *
  25  * A UWB radio controller is also a UWB device, so it embeds one...
  26  *
  27  * List of RCs comes from the 'struct class uwb_rc_class'.
  28  */
  29
  30 #include <linux/kernel.h>
  31 #include <linux/string.h>
  32 #include <linux/device.h>
  33 #include <linux/err.h>
  34 #include <linux/random.h>
  35 #include <linux/kdev_t.h>
  36 #include <linux/etherdevice.h>
  37 #include <linux/usb.h>
  38 #include <linux/slab.h>
  39 #include <linux/export.h>
  40
  41 #include "uwb-internal.h"
  42
  43 static int uwb_rc_index_match(struct device *dev, void *data)
  44 {
  45         int *index = data;
  46         struct uwb_rc *rc = dev_get_drvdata(dev);
  47
  48         if (rc->index == *index)
  49                 return 1;
  50         return 0;
  51 }
  52
  53 static struct uwb_rc *uwb_rc_find_by_index(int index)
  54 {
  55         struct device *dev;
  56         struct uwb_rc *rc = NULL;
  57
  58         dev = class_find_device(&uwb_rc_class, NULL, &index, uwb_rc_index_match);
  59         if (dev) {
  60                 rc = dev_get_drvdata(dev);
  61                 put_device(dev);
  62         }
  63
  64         return rc;
  65 }
  66
  67 static int uwb_rc_new_index(void)
  68 {
  69         int index = 0;
  70
  71         for (;;) {
  72                 if (!uwb_rc_find_by_index(index))
  73                         return index;
  74                 if (++index < 0)
  75                         index = 0;
  76         }
  77 }
  78
  79 /**
  80  * Release the backing device of a uwb_rc that has been dynamically allocated.
  81  */
  82 static void uwb_rc_sys_release(struct device *dev)
  83 {
  84         struct uwb_dev *uwb_dev = container_of(dev, struct uwb_dev, dev);
  85         struct uwb_rc *rc = container_of(uwb_dev, struct uwb_rc, uwb_dev);
  86
  87         uwb_rc_ie_release(rc);
  88         kfree(rc);
  89 }
  90
  91
  92 void uwb_rc_init(struct uwb_rc *rc)
  93 {
  94         struct uwb_dev *uwb_dev = &rc->uwb_dev;
  95
  96         uwb_dev_init(uwb_dev);
  97         rc->uwb_dev.dev.class = &uwb_rc_class;
  98         rc->uwb_dev.dev.release = uwb_rc_sys_release;
  99         uwb_rc_neh_create(rc);
 100         rc->beaconing = -1;
 101         rc->scan_type = UWB_SCAN_DISABLED;
 102         INIT_LIST_HEAD(&rc->notifs_chain.list);
 103         mutex_init(&rc->notifs_chain.mutex);
 104         INIT_LIST_HEAD(&rc->uwb_beca.list);
 105         mutex_init(&rc->uwb_beca.mutex);
 106         uwb_drp_avail_init(rc);
 107         uwb_rc_ie_init(rc);
 108         uwb_rsv_init(rc);
 109         uwb_rc_pal_init(rc);
 110 }
 111 EXPORT_SYMBOL_GPL(uwb_rc_init);
 112
 113
 114 struct uwb_rc *uwb_rc_alloc(void)
 115 {
 116         struct uwb_rc *rc;
 117         rc = kzalloc(sizeof(*rc), GFP_KERNEL);
 118         if (rc == NULL)
 119                 return NULL;
 120         uwb_rc_init(rc);
 121         return rc;
 122 }
 123 EXPORT_SYMBOL_GPL(uwb_rc_alloc);
 124
 125 static struct attribute *rc_attrs[] = {
 126                 &dev_attr_mac_address.attr,
 127                 &dev_attr_scan.attr,
 128                 &dev_attr_beacon.attr,
 129                 NULL,
 130 };
 131
 132 static struct attribute_group rc_attr_group = {
 133         .attrs = rc_attrs,
 134 };
 135
 136 /*
 137  * Registration of sysfs specific stuff
 138  */
 139 static int uwb_rc_sys_add(struct uwb_rc *rc)
 140 {
 141         return sysfs_create_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
 142 }
 143
 144
 145 static void __uwb_rc_sys_rm(struct uwb_rc *rc)
 146 {
 147         sysfs_remove_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
 148 }
 149
 150 /**
 151  * uwb_rc_mac_addr_setup - get an RC's EUI-48 address or set it
 152  * @rc:  the radio controller.
 153  *
 154  * If the EUI-48 address is 00:00:00:00:00:00 or FF:FF:FF:FF:FF:FF
 155  * then a random locally administered EUI-48 is generated and set on
 156  * the device.  The probability of address collisions is sufficiently
 157  * unlikely (1/2^40 = 9.1e-13) that they're not checked for.
 158  */
 159 static
 160 int uwb_rc_mac_addr_setup(struct uwb_rc *rc)
 161 {
 162         int result;
 163         struct device *dev = &rc->uwb_dev.dev;
 164         struct uwb_dev *uwb_dev = &rc->uwb_dev;
 165         char devname[UWB_ADDR_STRSIZE];
 166         struct uwb_mac_addr addr;
 167
 168         result = uwb_rc_mac_addr_get(rc, &addr);
 169         if (result < 0) {
 170                 dev_err(dev, "cannot retrieve UWB EUI-48 address: %d\n", result);
 171                 return result;
 172         }
 173
 174         if (uwb_mac_addr_unset(&addr) || uwb_mac_addr_bcast(&addr)) {
 175                 addr.data[0] = 0x02; /* locally administered and unicast */
 176                 get_random_bytes(&addr.data[1], sizeof(addr.data)-1);
 177
 178                 result = uwb_rc_mac_addr_set(rc, &addr);
 179                 if (result < 0) {
 180                         uwb_mac_addr_print(devname, sizeof(devname), &addr);
 181                         dev_err(dev, "cannot set EUI-48 address %s: %d\n",
 182                                 devname, result);
 183                         return result;
 184                 }
 185         }
 186         uwb_dev->mac_addr = addr;
 187         return 0;
 188 }
 189
 190
 191
 192 static int uwb_rc_setup(struct uwb_rc *rc)
 193 {
 194         int result;
 195         struct device *dev = &rc->uwb_dev.dev;
 196
 197         result = uwb_radio_setup(rc);
 198         if (result < 0) {
 199                 dev_err(dev, "cannot setup UWB radio: %d\n", result);
 200                 goto error;
 201         }
 202         result = uwb_rc_mac_addr_setup(rc);
 203         if (result < 0) {
 204                 dev_err(dev, "cannot setup UWB MAC address: %d\n", result);
 205                 goto error;
 206         }
 207         result = uwb_rc_dev_addr_assign(rc);
 208         if (result < 0) {
 209                 dev_err(dev, "cannot assign UWB DevAddr: %d\n", result);
 210                 goto error;
 211         }
 212         result = uwb_rc_ie_setup(rc);
 213         if (result < 0) {
 214                 dev_err(dev, "cannot setup IE subsystem: %d\n", result);
 215                 goto error_ie_setup;
 216         }
 217         result = uwb_rsv_setup(rc);
 218         if (result < 0) {
 219                 dev_err(dev, "cannot setup reservation subsystem: %d\n", result);
 220                 goto error_rsv_setup;
 221         }
 222         uwb_dbg_add_rc(rc);
 223         return 0;
 224
 225 error_rsv_setup:
 226         uwb_rc_ie_release(rc);
 227 error_ie_setup:
 228 error:
 229         return result;
 230 }
 231
 232
 233 /**
 234  * Register a new UWB radio controller
 235  *
 236  * Did you call uwb_rc_init() on your rc?
 237  *
 238  * We assume that this is being called with a > 0 refcount on
 239  * it [through ops->{get|put}_device(). We'll take our own, though.
 240  *
 241  * @parent_dev is our real device, the one that provides the actual UWB device
 242  */
 243 int uwb_rc_add(struct uwb_rc *rc, struct device *parent_dev, void *priv)
 244 {
 245         int result;
 246         struct device *dev;
 247         char macbuf[UWB_ADDR_STRSIZE], devbuf[UWB_ADDR_STRSIZE];
 248
 249         rc->index = uwb_rc_new_index();
 250
 251         dev = &rc->uwb_dev.dev;
 252         dev_set_name(dev, "uwb%d", rc->index);
 253
 254         rc->priv = priv;
 255
 256         init_waitqueue_head(&rc->uwbd.wq);
 257         INIT_LIST_HEAD(&rc->uwbd.event_list);
 258         spin_lock_init(&rc->uwbd.event_list_lock);
 259
 260         uwbd_start(rc);
 261
 262         result = rc->start(rc);
 263         if (result < 0)
 264                 goto error_rc_start;
 265
 266         result = uwb_rc_setup(rc);
 267         if (result < 0) {
 268                 dev_err(dev, "cannot setup UWB radio controller: %d\n", result);
 269                 goto error_rc_setup;
 270         }
 271
 272         result = uwb_dev_add(&rc->uwb_dev, parent_dev, rc);
 273         if (result < 0 && result != -EADDRNOTAVAIL)
 274                 goto error_dev_add;
 275
 276         result = uwb_rc_sys_add(rc);
 277         if (result < 0) {
 278                 dev_err(parent_dev, "cannot register UWB radio controller "
 279                         "dev attributes: %d\n", result);
 280                 goto error_sys_add;
 281         }
 282
 283         uwb_mac_addr_print(macbuf, sizeof(macbuf), &rc->uwb_dev.mac_addr);
 284         uwb_dev_addr_print(devbuf, sizeof(devbuf), &rc->uwb_dev.dev_addr);
 285         dev_info(dev,
 286                  "new uwb radio controller (mac %s dev %s) on %s %s\n",
 287                  macbuf, devbuf, parent_dev->bus->name, dev_name(parent_dev));
 288         rc->ready = 1;
 289         return 0;
 290
 291 error_sys_add:
 292         uwb_dev_rm(&rc->uwb_dev);
 293 error_dev_add:
 294 error_rc_setup:
 295         rc->stop(rc);
 296 error_rc_start:
 297         uwbd_stop(rc);
 298         return result;
 299 }
 300 EXPORT_SYMBOL_GPL(uwb_rc_add);
 301
 302
 303 static int uwb_dev_offair_helper(struct device *dev, void *priv)
 304 {
 305         struct uwb_dev *uwb_dev = to_uwb_dev(dev);
 306
 307         return __uwb_dev_offair(uwb_dev, uwb_dev->rc);
 308 }
 309
 310 /*
 311  * Remove a Radio Controller; stop beaconing/scanning, disconnect all children
 312  */
 313 void uwb_rc_rm(struct uwb_rc *rc)
 314 {
 315         rc->ready = 0;
 316
 317         uwb_dbg_del_rc(rc);
 318         uwb_rsv_remove_all(rc);
 319         uwb_radio_shutdown(rc);
 320
 321         rc->stop(rc);
 322
 323         uwbd_stop(rc);
 324         uwb_rc_neh_destroy(rc);
 325
 326         uwb_dev_lock(&rc->uwb_dev);
 327         rc->priv = NULL;
 328         rc->cmd = NULL;
 329         uwb_dev_unlock(&rc->uwb_dev);
 330         mutex_lock(&rc->uwb_beca.mutex);
 331         uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
 332         __uwb_rc_sys_rm(rc);
 333         mutex_unlock(&rc->uwb_beca.mutex);
 334         uwb_rsv_cleanup(rc);
 335         uwb_beca_release(rc);
 336         uwb_dev_rm(&rc->uwb_dev);
 337 }
 338 EXPORT_SYMBOL_GPL(uwb_rc_rm);
 339
 340 static int find_rc_try_get(struct device *dev, void *data)
 341 {
 342         struct uwb_rc *target_rc = data;
 343         struct uwb_rc *rc = dev_get_drvdata(dev);
 344
 345         if (rc == NULL) {
 346                 WARN_ON(1);
 347                 return 0;
 348         }
 349         if (rc == target_rc) {
 350                 if (rc->ready == 0)
 351                         return 0;
 352                 else
 353                         return 1;
 354         }
 355         return 0;
 356 }
 357
 358 /**
 359  * Given a radio controller descriptor, validate and refcount it
 360  *
 361  * @returns NULL if the rc does not exist or is quiescing; the ptr to
 362  *               it otherwise.
 363  */
 364 struct uwb_rc *__uwb_rc_try_get(struct uwb_rc *target_rc)
 365 {
 366         struct device *dev;
 367         struct uwb_rc *rc = NULL;
 368
 369         dev = class_find_device(&uwb_rc_class, NULL, target_rc,
 370                                 find_rc_try_get);
 371         if (dev) {
 372                 rc = dev_get_drvdata(dev);
 373                 __uwb_rc_get(rc);
 374                 put_device(dev);
 375         }
 376
 377         return rc;
 378 }
 379 EXPORT_SYMBOL_GPL(__uwb_rc_try_get);
 380
 381 /*
 382  * RC get for external refcount acquirers...
 383  *
 384  * Increments the refcount of the device and it's backend modules
 385  */
 386 static inline struct uwb_rc *uwb_rc_get(struct uwb_rc *rc)
 387 {
 388         if (rc->ready == 0)
 389                 return NULL;
 390         uwb_dev_get(&rc->uwb_dev);
 391         return rc;
 392 }
 393
 394 static int find_rc_grandpa(struct device *dev, void *data)
 395 {
 396         struct device *grandpa_dev = data;
 397         struct uwb_rc *rc = dev_get_drvdata(dev);
 398
 399         if (rc->uwb_dev.dev.parent->parent == grandpa_dev) {
 400                 rc = uwb_rc_get(rc);
 401                 return 1;
 402         }
 403         return 0;
 404 }
 405
 406 /**
 407  * Locate and refcount a radio controller given a common grand-parent
 408  *
 409  * @grandpa_dev  Pointer to the 'grandparent' device structure.
 410  * @returns NULL If the rc does not exist or is quiescing; the ptr to
 411  *               it otherwise, properly referenced.
 412  *
 413  * The Radio Control interface (or the UWB Radio Controller) is always
 414  * an interface of a device. The parent is the interface, the
 415  * grandparent is the device that encapsulates the interface.
 416  *
 417  * There is no need to lock around as the "grandpa" would be
 418  * refcounted by the target, and to remove the referemes, the
 419  * uwb_rc_class->sem would have to be taken--we hold it, ergo we
 420  * should be safe.
 421  */
 422 struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *grandpa_dev)
 423 {
 424         struct device *dev;
 425         struct uwb_rc *rc = NULL;
 426
 427         dev = class_find_device(&uwb_rc_class, NULL, (void *)grandpa_dev,
 428                                 find_rc_grandpa);
 429         if (dev) {
 430                 rc = dev_get_drvdata(dev);
 431                 put_device(dev);
 432         }
 433
 434         return rc;
 435 }
 436 EXPORT_SYMBOL_GPL(uwb_rc_get_by_grandpa);
 437
 438 /**
 439  * Find a radio controller by device address
 440  *
 441  * @returns the pointer to the radio controller, properly referenced
 442  */
 443 static int find_rc_dev(struct device *dev, void *data)
 444 {
 445         struct uwb_dev_addr *addr = data;
 446         struct uwb_rc *rc = dev_get_drvdata(dev);
 447
 448         if (rc == NULL) {
 449                 WARN_ON(1);
 450                 return 0;
 451         }
 452         if (!uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, addr)) {
 453                 rc = uwb_rc_get(rc);
 454                 return 1;
 455         }
 456         return 0;
 457 }
 458
 459 struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *addr)
 460 {
 461         struct device *dev;
 462         struct uwb_rc *rc = NULL;
 463
 464         dev = class_find_device(&uwb_rc_class, NULL, (void *)addr,
 465                                 find_rc_dev);
 466         if (dev) {
 467                 rc = dev_get_drvdata(dev);
 468                 put_device(dev);
 469         }
 470
 471         return rc;
 472 }
 473 EXPORT_SYMBOL_GPL(uwb_rc_get_by_dev);
 474
 475 /**
 476  * Drop a reference on a radio controller
 477  *
 478  * This is the version that should be done by entities external to the
 479  * UWB Radio Control stack (ie: clients of the API).
 480  */
 481 void uwb_rc_put(struct uwb_rc *rc)
 482 {
 483         __uwb_rc_put(rc);
 484 }
 485 EXPORT_SYMBOL_GPL(uwb_rc_put);