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