git.oblomov.eu Git - linux-2.6/blob - drivers/uwb/est.c

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