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