linux/drivers/uwb/est.c
<<
>>
Prefs
   1/*
   2 * Ultra Wide Band Radio Control
   3 * Event Size Tables management
   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 * Infrastructure, code and data tables for guessing the size of
  26 * events received on the notification endpoints of UWB radio
  27 * controllers.
  28 *
  29 * You define a table of events and for each, its size and how to get
  30 * the extra size.
  31 *
  32 * ENTRY POINTS:
  33 *
  34 * uwb_est_{init/destroy}(): To initialize/release the EST subsystem.
  35 *
  36 * uwb_est_[u]register(): To un/register event size tables
  37 *   uwb_est_grow()
  38 *
  39 * uwb_est_find_size(): Get the size of an event
  40 *   uwb_est_get_size()
  41 */
  42#include <linux/spinlock.h>
  43#include <linux/slab.h>
  44#include <linux/export.h>
  45
  46#include "uwb-internal.h"
  47
  48struct uwb_est {
  49        u16 type_event_high;
  50        u16 vendor, product;
  51        u8 entries;
  52        const struct uwb_est_entry *entry;
  53};
  54
  55static struct uwb_est *uwb_est;
  56static u8 uwb_est_size;
  57static u8 uwb_est_used;
  58static DEFINE_RWLOCK(uwb_est_lock);
  59
  60/**
  61 * WUSB Standard Event Size Table, HWA-RC interface
  62 *
  63 * Sizes for events and notifications type 0 (general), high nibble 0.
  64 */
  65static
  66struct uwb_est_entry uwb_est_00_00xx[] = {
  67        [UWB_RC_EVT_IE_RCV] = {
  68                .size = sizeof(struct uwb_rc_evt_ie_rcv),
  69                .offset = 1 + offsetof(struct uwb_rc_evt_ie_rcv, wIELength),
  70        },
  71        [UWB_RC_EVT_BEACON] = {
  72                .size = sizeof(struct uwb_rc_evt_beacon),
  73                .offset = 1 + offsetof(struct uwb_rc_evt_beacon, wBeaconInfoLength),
  74        },
  75        [UWB_RC_EVT_BEACON_SIZE] = {
  76                .size = sizeof(struct uwb_rc_evt_beacon_size),
  77        },
  78        [UWB_RC_EVT_BPOIE_CHANGE] = {
  79                .size = sizeof(struct uwb_rc_evt_bpoie_change),
  80                .offset = 1 + offsetof(struct uwb_rc_evt_bpoie_change,
  81                                       wBPOIELength),
  82        },
  83        [UWB_RC_EVT_BP_SLOT_CHANGE] = {
  84                .size = sizeof(struct uwb_rc_evt_bp_slot_change),
  85        },
  86        [UWB_RC_EVT_BP_SWITCH_IE_RCV] = {
  87                .size = sizeof(struct uwb_rc_evt_bp_switch_ie_rcv),
  88                .offset = 1 + offsetof(struct uwb_rc_evt_bp_switch_ie_rcv, wIELength),
  89        },
  90        [UWB_RC_EVT_DEV_ADDR_CONFLICT] = {
  91                .size = sizeof(struct uwb_rc_evt_dev_addr_conflict),
  92        },
  93        [UWB_RC_EVT_DRP_AVAIL] = {
  94                .size = sizeof(struct uwb_rc_evt_drp_avail)
  95        },
  96        [UWB_RC_EVT_DRP] = {
  97                .size = sizeof(struct uwb_rc_evt_drp),
  98                .offset = 1 + offsetof(struct uwb_rc_evt_drp, ie_length),
  99        },
 100        [UWB_RC_EVT_BP_SWITCH_STATUS] = {
 101                .size = sizeof(struct uwb_rc_evt_bp_switch_status),
 102        },
 103        [UWB_RC_EVT_CMD_FRAME_RCV] = {
 104                .size = sizeof(struct uwb_rc_evt_cmd_frame_rcv),
 105                .offset = 1 + offsetof(struct uwb_rc_evt_cmd_frame_rcv, dataLength),
 106        },
 107        [UWB_RC_EVT_CHANNEL_CHANGE_IE_RCV] = {
 108                .size = sizeof(struct uwb_rc_evt_channel_change_ie_rcv),
 109                .offset = 1 + offsetof(struct uwb_rc_evt_channel_change_ie_rcv, wIELength),
 110        },
 111        [UWB_RC_CMD_CHANNEL_CHANGE] = {
 112                .size = sizeof(struct uwb_rc_evt_confirm),
 113        },
 114        [UWB_RC_CMD_DEV_ADDR_MGMT] = {
 115                .size = sizeof(struct uwb_rc_evt_dev_addr_mgmt) },
 116        [UWB_RC_CMD_GET_IE] = {
 117                .size = sizeof(struct uwb_rc_evt_get_ie),
 118                .offset = 1 + offsetof(struct uwb_rc_evt_get_ie, wIELength),
 119        },
 120        [UWB_RC_CMD_RESET] = {
 121                .size = sizeof(struct uwb_rc_evt_confirm),
 122        },
 123        [UWB_RC_CMD_SCAN] = {
 124                .size = sizeof(struct uwb_rc_evt_confirm),
 125        },
 126        [UWB_RC_CMD_SET_BEACON_FILTER] = {
 127                .size = sizeof(struct uwb_rc_evt_confirm),
 128        },
 129        [UWB_RC_CMD_SET_DRP_IE] = {
 130                .size = sizeof(struct uwb_rc_evt_set_drp_ie),
 131        },
 132        [UWB_RC_CMD_SET_IE] = {
 133                .size = sizeof(struct uwb_rc_evt_set_ie),
 134        },
 135        [UWB_RC_CMD_SET_NOTIFICATION_FILTER] = {
 136                .size = sizeof(struct uwb_rc_evt_confirm),
 137        },
 138        [UWB_RC_CMD_SET_TX_POWER] = {
 139                .size = sizeof(struct uwb_rc_evt_confirm),
 140        },
 141        [UWB_RC_CMD_SLEEP] = {
 142                .size = sizeof(struct uwb_rc_evt_confirm),
 143        },
 144        [UWB_RC_CMD_START_BEACON] = {
 145                .size = sizeof(struct uwb_rc_evt_confirm),
 146        },
 147        [UWB_RC_CMD_STOP_BEACON] = {
 148                .size = sizeof(struct uwb_rc_evt_confirm),
 149        },
 150        [UWB_RC_CMD_BP_MERGE] = {
 151                .size = sizeof(struct uwb_rc_evt_confirm),
 152        },
 153        [UWB_RC_CMD_SEND_COMMAND_FRAME] = {
 154                .size = sizeof(struct uwb_rc_evt_confirm),
 155        },
 156        [UWB_RC_CMD_SET_ASIE_NOTIF] = {
 157                .size = sizeof(struct uwb_rc_evt_confirm),
 158        },
 159};
 160
 161static
 162struct uwb_est_entry uwb_est_01_00xx[] = {
 163        [UWB_RC_DAA_ENERGY_DETECTED] = {
 164                .size = sizeof(struct uwb_rc_evt_daa_energy_detected),
 165        },
 166        [UWB_RC_SET_DAA_ENERGY_MASK] = {
 167                .size = sizeof(struct uwb_rc_evt_set_daa_energy_mask),
 168        },
 169        [UWB_RC_SET_NOTIFICATION_FILTER_EX] = {
 170                .size = sizeof(struct uwb_rc_evt_set_notification_filter_ex),
 171        },
 172};
 173
 174/**
 175 * Initialize the EST subsystem
 176 *
 177 * Register the standard tables also.
 178 *
 179 * FIXME: tag init
 180 */
 181int uwb_est_create(void)
 182{
 183        int result;
 184
 185        uwb_est_size = 2;
 186        uwb_est_used = 0;
 187        uwb_est = kcalloc(uwb_est_size, sizeof(uwb_est[0]), GFP_KERNEL);
 188        if (uwb_est == NULL)
 189                return -ENOMEM;
 190
 191        result = uwb_est_register(UWB_RC_CET_GENERAL, 0, 0xffff, 0xffff,
 192                                  uwb_est_00_00xx, ARRAY_SIZE(uwb_est_00_00xx));
 193        if (result < 0)
 194                goto out;
 195        result = uwb_est_register(UWB_RC_CET_EX_TYPE_1, 0, 0xffff, 0xffff,
 196                                  uwb_est_01_00xx, ARRAY_SIZE(uwb_est_01_00xx));
 197out:
 198        return result;
 199}
 200
 201
 202/** Clean it up */
 203void uwb_est_destroy(void)
 204{
 205        kfree(uwb_est);
 206        uwb_est = NULL;
 207        uwb_est_size = uwb_est_used = 0;
 208}
 209
 210
 211/**
 212 * Double the capacity of the EST table
 213 *
 214 * @returns 0 if ok, < 0 errno no error.
 215 */
 216static
 217int uwb_est_grow(void)
 218{
 219        size_t actual_size = uwb_est_size * sizeof(uwb_est[0]);
 220        void *new = kmalloc(2 * actual_size, GFP_ATOMIC);
 221        if (new == NULL)
 222                return -ENOMEM;
 223        memcpy(new, uwb_est, actual_size);
 224        memset(new + actual_size, 0, actual_size);
 225        kfree(uwb_est);
 226        uwb_est = new;
 227        uwb_est_size *= 2;
 228        return 0;
 229}
 230
 231
 232/**
 233 * Register an event size table
 234 *
 235 * Makes room for it if the table is full, and then inserts  it in the
 236 * right position (entries are sorted by type, event_high, vendor and
 237 * then product).
 238 *
 239 * @vendor:  vendor code for matching against the device (0x0000 and
 240 *           0xffff mean any); use 0x0000 to force all to match without
 241 *           checking possible vendor specific ones, 0xfffff to match
 242 *           after checking vendor specific ones.
 243 *
 244 * @product: product code from that vendor; same matching rules, use
 245 *           0x0000 for not allowing vendor specific matches, 0xffff
 246 *           for allowing.
 247 *
 248 * This arragement just makes the tables sort differenty. Because the
 249 * table is sorted by growing type-event_high-vendor-product, a zero
 250 * vendor will match before than a 0x456a vendor, that will match
 251 * before a 0xfffff vendor.
 252 *
 253 * @returns 0 if ok, < 0 errno on error (-ENOENT if not found).
 254 */
 255/* FIXME: add bus type to vendor/product code */
 256int uwb_est_register(u8 type, u8 event_high, u16 vendor, u16 product,
 257                     const struct uwb_est_entry *entry, size_t entries)
 258{
 259        unsigned long flags;
 260        unsigned itr;
 261        u16 type_event_high;
 262        int result = 0;
 263
 264        write_lock_irqsave(&uwb_est_lock, flags);
 265        if (uwb_est_used == uwb_est_size) {
 266                result = uwb_est_grow();
 267                if (result < 0)
 268                        goto out;
 269        }
 270        /* Find the right spot to insert it in */
 271        type_event_high = type << 8 | event_high;
 272        for (itr = 0; itr < uwb_est_used; itr++)
 273                if (uwb_est[itr].type_event_high < type
 274                    && uwb_est[itr].vendor < vendor
 275                    && uwb_est[itr].product < product)
 276                        break;
 277
 278        /* Shift others to make room for the new one? */
 279        if (itr < uwb_est_used)
 280                memmove(&uwb_est[itr+1], &uwb_est[itr], uwb_est_used - itr);
 281        uwb_est[itr].type_event_high = type << 8 | event_high;
 282        uwb_est[itr].vendor = vendor;
 283        uwb_est[itr].product = product;
 284        uwb_est[itr].entry = entry;
 285        uwb_est[itr].entries = entries;
 286        uwb_est_used++;
 287out:
 288        write_unlock_irqrestore(&uwb_est_lock, flags);
 289        return result;
 290}
 291EXPORT_SYMBOL_GPL(uwb_est_register);
 292
 293
 294/**
 295 * Unregister an event size table
 296 *
 297 * This just removes the specified entry and moves the ones after it
 298 * to fill in the gap. This is needed to keep the list sorted; no
 299 * reallocation is done to reduce the size of the table.
 300 *
 301 * We unregister by all the data we used to register instead of by
 302 * pointer to the @entry array because we might have used the same
 303 * table for a bunch of IDs (for example).
 304 *
 305 * @returns 0 if ok, < 0 errno on error (-ENOENT if not found).
 306 */
 307int uwb_est_unregister(u8 type, u8 event_high, u16 vendor, u16 product,
 308                       const struct uwb_est_entry *entry, size_t entries)
 309{
 310        unsigned long flags;
 311        unsigned itr;
 312        struct uwb_est est_cmp = {
 313                .type_event_high = type << 8 | event_high,
 314                .vendor = vendor,
 315                .product = product,
 316                .entry = entry,
 317                .entries = entries
 318        };
 319        write_lock_irqsave(&uwb_est_lock, flags);
 320        for (itr = 0; itr < uwb_est_used; itr++)
 321                if (!memcmp(&uwb_est[itr], &est_cmp, sizeof(est_cmp)))
 322                        goto found;
 323        write_unlock_irqrestore(&uwb_est_lock, flags);
 324        return -ENOENT;
 325
 326found:
 327        if (itr < uwb_est_used - 1)     /* Not last one? move ones above */
 328                memmove(&uwb_est[itr], &uwb_est[itr+1], uwb_est_used - itr - 1);
 329        uwb_est_used--;
 330        write_unlock_irqrestore(&uwb_est_lock, flags);
 331        return 0;
 332}
 333EXPORT_SYMBOL_GPL(uwb_est_unregister);
 334
 335
 336/**
 337 * Get the size of an event from a table
 338 *
 339 * @rceb: pointer to the buffer with the event
 340 * @rceb_size: size of the area pointed to by @rceb in bytes.
 341 * @returns: > 0      Size of the event
 342 *           -ENOSPC  An area big enough was not provided to look
 343 *                    ahead into the event's guts and guess the size.
 344 *           -EINVAL  Unknown event code (wEvent).
 345 *
 346 * This will look at the received RCEB and guess what is the total
 347 * size. For variable sized events, it will look further ahead into
 348 * their length field to see how much data should be read.
 349 *
 350 * Note this size is *not* final--the neh (Notification/Event Handle)
 351 * might specificy an extra size to add.
 352 */
 353static
 354ssize_t uwb_est_get_size(struct uwb_rc *uwb_rc, struct uwb_est *est,
 355                         u8 event_low, const struct uwb_rceb *rceb,
 356                         size_t rceb_size)
 357{
 358        unsigned offset;
 359        ssize_t size;
 360        struct device *dev = &uwb_rc->uwb_dev.dev;
 361        const struct uwb_est_entry *entry;
 362
 363        size = -ENOENT;
 364        if (event_low >= est->entries) {        /* in range? */
 365                dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u out of range\n",
 366                        est, est->type_event_high, est->vendor, est->product,
 367                        est->entries, event_low);
 368                goto out;
 369        }
 370        size = -ENOENT;
 371        entry = &est->entry[event_low];
 372        if (entry->size == 0 && entry->offset == 0) {   /* unknown? */
 373                dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u unknown\n",
 374                        est, est->type_event_high, est->vendor, est->product,
 375                        est->entries, event_low);
 376                goto out;
 377        }
 378        offset = entry->offset; /* extra fries with that? */
 379        if (offset == 0)
 380                size = entry->size;
 381        else {
 382                /* Ops, got an extra size field at 'offset'--read it */
 383                const void *ptr = rceb;
 384                size_t type_size = 0;
 385                offset--;
 386                size = -ENOSPC;                 /* enough data for more? */
 387                switch (entry->type) {
 388                case UWB_EST_16:  type_size = sizeof(__le16); break;
 389                case UWB_EST_8:   type_size = sizeof(u8);     break;
 390                default:         BUG();
 391                }
 392                if (offset + type_size > rceb_size) {
 393                        dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: "
 394                                "not enough data to read extra size\n",
 395                                est, est->type_event_high, est->vendor,
 396                                est->product, est->entries);
 397                        goto out;
 398                }
 399                size = entry->size;
 400                ptr += offset;
 401                switch (entry->type) {
 402                case UWB_EST_16:  size += le16_to_cpu(*(__le16 *)ptr); break;
 403                case UWB_EST_8:   size += *(u8 *)ptr;                  break;
 404                default:         BUG();
 405                }
 406        }
 407out:
 408        return size;
 409}
 410
 411
 412/**
 413 * Guesses the size of a WA event
 414 *
 415 * @rceb: pointer to the buffer with the event
 416 * @rceb_size: size of the area pointed to by @rceb in bytes.
 417 * @returns: > 0      Size of the event
 418 *           -ENOSPC  An area big enough was not provided to look
 419 *                    ahead into the event's guts and guess the size.
 420 *           -EINVAL  Unknown event code (wEvent).
 421 *
 422 * This will look at the received RCEB and guess what is the total
 423 * size by checking all the tables registered with
 424 * uwb_est_register(). For variable sized events, it will look further
 425 * ahead into their length field to see how much data should be read.
 426 *
 427 * Note this size is *not* final--the neh (Notification/Event Handle)
 428 * might specificy an extra size to add or replace.
 429 */
 430ssize_t uwb_est_find_size(struct uwb_rc *rc, const struct uwb_rceb *rceb,
 431                          size_t rceb_size)
 432{
 433        /* FIXME: add vendor/product data */
 434        ssize_t size;
 435        struct device *dev = &rc->uwb_dev.dev;
 436        unsigned long flags;
 437        unsigned itr;
 438        u16 type_event_high, event;
 439        u8 *ptr = (u8 *) rceb;
 440
 441        read_lock_irqsave(&uwb_est_lock, flags);
 442        size = -ENOSPC;
 443        if (rceb_size < sizeof(*rceb))
 444                goto out;
 445        event = le16_to_cpu(rceb->wEvent);
 446        type_event_high = rceb->bEventType << 8 | (event & 0xff00) >> 8;
 447        for (itr = 0; itr < uwb_est_used; itr++) {
 448                if (uwb_est[itr].type_event_high != type_event_high)
 449                        continue;
 450                size = uwb_est_get_size(rc, &uwb_est[itr],
 451                                        event & 0x00ff, rceb, rceb_size);
 452                /* try more tables that might handle the same type */
 453                if (size != -ENOENT)
 454                        goto out;
 455        }
 456        dev_dbg(dev, "event 0x%02x/%04x/%02x: no handlers available; "
 457                "RCEB %02x %02x %02x %02x\n",
 458                (unsigned) rceb->bEventType,
 459                (unsigned) le16_to_cpu(rceb->wEvent),
 460                (unsigned) rceb->bEventContext,
 461                ptr[0], ptr[1], ptr[2], ptr[3]);
 462        size = -ENOENT;
 463out:
 464        read_unlock_irqrestore(&uwb_est_lock, flags);
 465        return size;
 466}
 467EXPORT_SYMBOL_GPL(uwb_est_find_size);
 468
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.