drivers/uwb/rsv.c

   1 /*
   2  * UWB reservation management.
   3  *
   4  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version
   8  * 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include <linux/kernel.h>
  19 #include <linux/uwb.h>
  20 #include <linux/random.h>
  21
  22 #include "uwb-internal.h"
  23
  24 static void uwb_rsv_timer(unsigned long arg);
  25
  26 static const char *rsv_states[] = {
  27         [UWB_RSV_STATE_NONE]                 = "none            ",
  28         [UWB_RSV_STATE_O_INITIATED]          = "o initiated     ",
  29         [UWB_RSV_STATE_O_PENDING]            = "o pending       ",
  30         [UWB_RSV_STATE_O_MODIFIED]           = "o modified      ",
  31         [UWB_RSV_STATE_O_ESTABLISHED]        = "o established   ",
  32         [UWB_RSV_STATE_O_TO_BE_MOVED]        = "o to be moved   ",
  33         [UWB_RSV_STATE_O_MOVE_EXPANDING]     = "o move expanding",
  34         [UWB_RSV_STATE_O_MOVE_COMBINING]     = "o move combining",
  35         [UWB_RSV_STATE_O_MOVE_REDUCING]      = "o move reducing ",
  36         [UWB_RSV_STATE_T_ACCEPTED]           = "t accepted      ",
  37         [UWB_RSV_STATE_T_CONFLICT]           = "t conflict      ",
  38         [UWB_RSV_STATE_T_PENDING]            = "t pending       ",
  39         [UWB_RSV_STATE_T_DENIED]             = "t denied        ",
  40         [UWB_RSV_STATE_T_RESIZED]            = "t resized       ",
  41         [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = "t expanding acc ",
  42         [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = "t expanding conf",
  43         [UWB_RSV_STATE_T_EXPANDING_PENDING]  = "t expanding pend",
  44         [UWB_RSV_STATE_T_EXPANDING_DENIED]   = "t expanding den ",
  45 };
  46
  47 static const char *rsv_types[] = {
  48         [UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
  49         [UWB_DRP_TYPE_HARD]     = "hard",
  50         [UWB_DRP_TYPE_SOFT]     = "soft",
  51         [UWB_DRP_TYPE_PRIVATE]  = "private",
  52         [UWB_DRP_TYPE_PCA]      = "pca",
  53 };
  54
  55 bool uwb_rsv_has_two_drp_ies(struct uwb_rsv *rsv)
  56 {
  57         static const bool has_two_drp_ies[] = {
  58                 [UWB_RSV_STATE_O_INITIATED]               = false,
  59                 [UWB_RSV_STATE_O_PENDING]                 = false,
  60                 [UWB_RSV_STATE_O_MODIFIED]                = false,
  61                 [UWB_RSV_STATE_O_ESTABLISHED]             = false,
  62                 [UWB_RSV_STATE_O_TO_BE_MOVED]             = false,
  63                 [UWB_RSV_STATE_O_MOVE_COMBINING]          = false,
  64                 [UWB_RSV_STATE_O_MOVE_REDUCING]           = false,
  65                 [UWB_RSV_STATE_O_MOVE_EXPANDING]          = true,
  66                 [UWB_RSV_STATE_T_ACCEPTED]                = false,
  67                 [UWB_RSV_STATE_T_CONFLICT]                = false,
  68                 [UWB_RSV_STATE_T_PENDING]                 = false,
  69                 [UWB_RSV_STATE_T_DENIED]                  = false,
  70                 [UWB_RSV_STATE_T_RESIZED]                 = false,
  71                 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED]      = true,
  72                 [UWB_RSV_STATE_T_EXPANDING_CONFLICT]      = true,
  73                 [UWB_RSV_STATE_T_EXPANDING_PENDING]       = true,
  74                 [UWB_RSV_STATE_T_EXPANDING_DENIED]        = true,
  75         };
  76
  77         return has_two_drp_ies[rsv->state];
  78 }
  79
  80 /**
  81  * uwb_rsv_state_str - return a string for a reservation state
  82  * @state: the reservation state.
  83  */
  84 const char *uwb_rsv_state_str(enum uwb_rsv_state state)
  85 {
  86         if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
  87                 return "unknown";
  88         return rsv_states[state];
  89 }
  90 EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
  91
  92 /**
  93  * uwb_rsv_type_str - return a string for a reservation type
  94  * @type: the reservation type
  95  */
  96 const char *uwb_rsv_type_str(enum uwb_drp_type type)
  97 {
  98         if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
  99                 return "invalid";
 100         return rsv_types[type];
 101 }
 102 EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
 103
 104 void uwb_rsv_dump(char *text, struct uwb_rsv *rsv)
 105 {
 106         struct device *dev = &rsv->rc->uwb_dev.dev;
 107         struct uwb_dev_addr devaddr;
 108         char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
 109
 110         uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
 111         if (rsv->target.type == UWB_RSV_TARGET_DEV)
 112                 devaddr = rsv->target.dev->dev_addr;
 113         else
 114                 devaddr = rsv->target.devaddr;
 115         uwb_dev_addr_print(target, sizeof(target), &devaddr);
 116
 117         dev_dbg(dev, "rsv %s %s -> %s: %s\n",
 118                 text, owner, target, uwb_rsv_state_str(rsv->state));
 119 }
 120
 121 static void uwb_rsv_release(struct kref *kref)
 122 {
 123         struct uwb_rsv *rsv = container_of(kref, struct uwb_rsv, kref);
 124
 125         kfree(rsv);
 126 }
 127
 128 void uwb_rsv_get(struct uwb_rsv *rsv)
 129 {
 130         kref_get(&rsv->kref);
 131 }
 132
 133 void uwb_rsv_put(struct uwb_rsv *rsv)
 134 {
 135         kref_put(&rsv->kref, uwb_rsv_release);
 136 }
 137
 138 /*
 139  * Get a free stream index for a reservation.
 140  *
 141  * If the target is a DevAddr (e.g., a WUSB cluster reservation) then
 142  * the stream is allocated from a pool of per-RC stream indexes,
 143  * otherwise a unique stream index for the target is selected.
 144  */
 145 static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
 146 {
 147         struct uwb_rc *rc = rsv->rc;
 148         struct device *dev = &rc->uwb_dev.dev;
 149         unsigned long *streams_bm;
 150         int stream;
 151
 152         switch (rsv->target.type) {
 153         case UWB_RSV_TARGET_DEV:
 154                 streams_bm = rsv->target.dev->streams;
 155                 break;
 156         case UWB_RSV_TARGET_DEVADDR:
 157                 streams_bm = rc->uwb_dev.streams;
 158                 break;
 159         default:
 160                 return -EINVAL;
 161         }
 162
 163         stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
 164         if (stream >= UWB_NUM_STREAMS)
 165                 return -EBUSY;
 166
 167         rsv->stream = stream;
 168         set_bit(stream, streams_bm);
 169
 170         dev_dbg(dev, "get stream %d\n", rsv->stream);
 171
 172         return 0;
 173 }
 174
 175 static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
 176 {
 177         struct uwb_rc *rc = rsv->rc;
 178         struct device *dev = &rc->uwb_dev.dev;
 179         unsigned long *streams_bm;
 180
 181         switch (rsv->target.type) {
 182         case UWB_RSV_TARGET_DEV:
 183                 streams_bm = rsv->target.dev->streams;
 184                 break;
 185         case UWB_RSV_TARGET_DEVADDR:
 186                 streams_bm = rc->uwb_dev.streams;
 187                 break;
 188         default:
 189                 return;
 190         }
 191
 192         clear_bit(rsv->stream, streams_bm);
 193
 194         dev_dbg(dev, "put stream %d\n", rsv->stream);
 195 }
 196
 197 void uwb_rsv_backoff_win_timer(unsigned long arg)
 198 {
 199         struct uwb_drp_backoff_win *bow = (struct uwb_drp_backoff_win *)arg;
 200         struct uwb_rc *rc = container_of(bow, struct uwb_rc, bow);
 201         struct device *dev = &rc->uwb_dev.dev;
 202
 203         bow->can_reserve_extra_mases = true;
 204         if (bow->total_expired <= 4) {
 205                 bow->total_expired++;
 206         } else {
 207                 /* after 4 backoff window has expired we can exit from
 208                  * the backoff procedure */
 209                 bow->total_expired = 0;
 210                 bow->window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
 211         }
 212         dev_dbg(dev, "backoff_win_timer total_expired=%d, n=%d\n: ", bow->total_expired, bow->n);
 213
 214         /* try to relocate all the "to be moved" relocations */
 215         uwb_rsv_handle_drp_avail_change(rc);
 216 }
 217
 218 void uwb_rsv_backoff_win_increment(struct uwb_rc *rc)
 219 {
 220         struct uwb_drp_backoff_win *bow = &rc->bow;
 221         struct device *dev = &rc->uwb_dev.dev;
 222         unsigned timeout_us;
 223
 224         dev_dbg(dev, "backoff_win_increment: window=%d\n", bow->window);
 225
 226         bow->can_reserve_extra_mases = false;
 227
 228         if((bow->window << 1) == UWB_DRP_BACKOFF_WIN_MAX)
 229                 return;
 230
 231         bow->window <<= 1;
 232         bow->n = random32() & (bow->window - 1);
 233         dev_dbg(dev, "new_window=%d, n=%d\n: ", bow->window, bow->n);
 234
 235         /* reset the timer associated variables */
 236         timeout_us = bow->n * UWB_SUPERFRAME_LENGTH_US;
 237         bow->total_expired = 0;
 238         mod_timer(&bow->timer, jiffies + usecs_to_jiffies(timeout_us));
 239 }
 240
 241 static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
 242 {
 243         int sframes = UWB_MAX_LOST_BEACONS;
 244
 245         /*
 246          * Multicast reservations can become established within 1
 247          * super frame and should not be terminated if no response is
 248          * received.
 249          */
 250         if (rsv->is_multicast) {
 251                 if (rsv->state == UWB_RSV_STATE_O_INITIATED
 252                     || rsv->state == UWB_RSV_STATE_O_MOVE_EXPANDING
 253                     || rsv->state == UWB_RSV_STATE_O_MOVE_COMBINING
 254                     || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING)
 255                         sframes = 1;
 256                 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
 257                         sframes = 0;
 258
 259         }
 260
 261         if (sframes > 0) {
 262                 /*
 263                  * Add an additional 2 superframes to account for the
 264                  * time to send the SET DRP IE command.
 265                  */
 266                 unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
 267                 mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
 268         } else
 269                 del_timer(&rsv->timer);
 270 }
 271
 272 /*
 273  * Update a reservations state, and schedule an update of the
 274  * transmitted DRP IEs.
 275  */
 276 static void uwb_rsv_state_update(struct uwb_rsv *rsv,
 277                                  enum uwb_rsv_state new_state)
 278 {
 279         rsv->state = new_state;
 280         rsv->ie_valid = false;
 281
 282         uwb_rsv_dump("SU", rsv);
 283
 284         uwb_rsv_stroke_timer(rsv);
 285         uwb_rsv_sched_update(rsv->rc);
 286 }
 287
 288 static void uwb_rsv_callback(struct uwb_rsv *rsv)
 289 {
 290         if (rsv->callback)
 291                 rsv->callback(rsv);
 292 }
 293
 294 void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
 295 {
 296         struct uwb_rsv_move *mv = &rsv->mv;
 297
 298         if (rsv->state == new_state) {
 299                 switch (rsv->state) {
 300                 case UWB_RSV_STATE_O_ESTABLISHED:
 301                 case UWB_RSV_STATE_O_MOVE_EXPANDING:
 302                 case UWB_RSV_STATE_O_MOVE_COMBINING:
 303                 case UWB_RSV_STATE_O_MOVE_REDUCING:
 304                 case UWB_RSV_STATE_T_ACCEPTED:
 305                 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
 306                 case UWB_RSV_STATE_T_RESIZED:
 307                 case UWB_RSV_STATE_NONE:
 308                         uwb_rsv_stroke_timer(rsv);
 309                         break;
 310                 default:
 311                         /* Expecting a state transition so leave timer
 312                            as-is. */
 313                         break;
 314                 }
 315                 return;
 316         }
 317
 318         uwb_rsv_dump("SC", rsv);
 319
 320         switch (new_state) {
 321         case UWB_RSV_STATE_NONE:
 322                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
 323                 uwb_rsv_callback(rsv);
 324                 break;
 325         case UWB_RSV_STATE_O_INITIATED:
 326                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
 327                 break;
 328         case UWB_RSV_STATE_O_PENDING:
 329                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
 330                 break;
 331         case UWB_RSV_STATE_O_MODIFIED:
 332                 /* in the companion there are the MASes to drop */
 333                 bitmap_andnot(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
 334                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MODIFIED);
 335                 break;
 336         case UWB_RSV_STATE_O_ESTABLISHED:
 337                 if (rsv->state == UWB_RSV_STATE_O_MODIFIED
 338                     || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING) {
 339                         uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
 340                         rsv->needs_release_companion_mas = false;
 341                 }
 342                 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
 343                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 344                 uwb_rsv_callback(rsv);
 345                 break;
 346         case UWB_RSV_STATE_O_MOVE_EXPANDING:
 347                 rsv->needs_release_companion_mas = true;
 348                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
 349                 break;
 350         case UWB_RSV_STATE_O_MOVE_COMBINING:
 351                 rsv->needs_release_companion_mas = false;
 352                 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
 353                 bitmap_or(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
 354                 rsv->mas.safe   += mv->companion_mas.safe;
 355                 rsv->mas.unsafe += mv->companion_mas.unsafe;
 356                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
 357                 break;
 358         case UWB_RSV_STATE_O_MOVE_REDUCING:
 359                 bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
 360                 rsv->needs_release_companion_mas = true;
 361                 rsv->mas.safe   = mv->final_mas.safe;
 362                 rsv->mas.unsafe = mv->final_mas.unsafe;
 363                 bitmap_copy(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
 364                 bitmap_copy(rsv->mas.unsafe_bm, mv->final_mas.unsafe_bm, UWB_NUM_MAS);
 365                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
 366                 break;
 367         case UWB_RSV_STATE_T_ACCEPTED:
 368         case UWB_RSV_STATE_T_RESIZED:
 369                 rsv->needs_release_companion_mas = false;
 370                 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
 371                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
 372                 uwb_rsv_callback(rsv);
 373                 break;
 374         case UWB_RSV_STATE_T_DENIED:
 375                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
 376                 break;
 377         case UWB_RSV_STATE_T_CONFLICT:
 378                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_CONFLICT);
 379                 break;
 380         case UWB_RSV_STATE_T_PENDING:
 381                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_PENDING);
 382                 break;
 383         case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
 384                 rsv->needs_release_companion_mas = true;
 385                 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
 386                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
 387                 break;
 388         default:
 389                 dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
 390                         uwb_rsv_state_str(new_state), new_state);
 391         }
 392 }
 393
 394 static void uwb_rsv_handle_timeout_work(struct work_struct *work)
 395 {
 396         struct uwb_rsv *rsv = container_of(work, struct uwb_rsv,
 397                                            handle_timeout_work);
 398         struct uwb_rc *rc = rsv->rc;
 399
 400         mutex_lock(&rc->rsvs_mutex);
 401
 402         uwb_rsv_dump("TO", rsv);
 403
 404         switch (rsv->state) {
 405         case UWB_RSV_STATE_O_INITIATED:
 406                 if (rsv->is_multicast) {
 407                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 408                         goto unlock;
 409                 }
 410                 break;
 411         case UWB_RSV_STATE_O_MOVE_EXPANDING:
 412                 if (rsv->is_multicast) {
 413                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
 414                         goto unlock;
 415                 }
 416                 break;
 417         case UWB_RSV_STATE_O_MOVE_COMBINING:
 418                 if (rsv->is_multicast) {
 419                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
 420                         goto unlock;
 421                 }
 422                 break;
 423         case UWB_RSV_STATE_O_MOVE_REDUCING:
 424                 if (rsv->is_multicast) {
 425                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 426                         goto unlock;
 427                 }
 428                 break;
 429         case UWB_RSV_STATE_O_ESTABLISHED:
 430                 if (rsv->is_multicast)
 431                         goto unlock;
 432                 break;
 433         case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
 434                 /*
 435                  * The time out could be for the main or of the
 436                  * companion DRP, assume it's for the companion and
 437                  * drop that first.  A further time out is required to
 438                  * drop the main.
 439                  */
 440                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
 441                 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
 442                 goto unlock;
 443         default:
 444                 break;
 445         }
 446
 447         uwb_rsv_remove(rsv);
 448
 449 unlock:
 450         mutex_unlock(&rc->rsvs_mutex);
 451 }
 452
 453 static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
 454 {
 455         struct uwb_rsv *rsv;
 456
 457         rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
 458         if (!rsv)
 459                 return NULL;
 460
 461         INIT_LIST_HEAD(&rsv->rc_node);
 462         INIT_LIST_HEAD(&rsv->pal_node);
 463         kref_init(&rsv->kref);
 464         init_timer(&rsv->timer);
 465         rsv->timer.function = uwb_rsv_timer;
 466         rsv->timer.data     = (unsigned long)rsv;
 467
 468         rsv->rc = rc;
 469         INIT_WORK(&rsv->handle_timeout_work, uwb_rsv_handle_timeout_work);
 470
 471         return rsv;
 472 }
 473
 474 /**
 475  * uwb_rsv_create - allocate and initialize a UWB reservation structure
 476  * @rc: the radio controller
 477  * @cb: callback to use when the reservation completes or terminates
 478  * @pal_priv: data private to the PAL to be passed in the callback
 479  *
 480  * The callback is called when the state of the reservation changes from:
 481  *
 482  *   - pending to accepted
 483  *   - pending to denined
 484  *   - accepted to terminated
 485  *   - pending to terminated
 486  */
 487 struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
 488 {
 489         struct uwb_rsv *rsv;
 490
 491         rsv = uwb_rsv_alloc(rc);
 492         if (!rsv)
 493                 return NULL;
 494
 495         rsv->callback = cb;
 496         rsv->pal_priv = pal_priv;
 497
 498         return rsv;
 499 }
 500 EXPORT_SYMBOL_GPL(uwb_rsv_create);
 501
 502 void uwb_rsv_remove(struct uwb_rsv *rsv)
 503 {
 504         uwb_rsv_dump("RM", rsv);
 505
 506         if (rsv->state != UWB_RSV_STATE_NONE)
 507                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
 508
 509         if (rsv->needs_release_companion_mas)
 510                 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
 511         uwb_drp_avail_release(rsv->rc, &rsv->mas);
 512
 513         if (uwb_rsv_is_owner(rsv))
 514                 uwb_rsv_put_stream(rsv);
 515
 516         uwb_dev_put(rsv->owner);
 517         if (rsv->target.type == UWB_RSV_TARGET_DEV)
 518                 uwb_dev_put(rsv->target.dev);
 519
 520         list_del_init(&rsv->rc_node);
 521         uwb_rsv_put(rsv);
 522 }
 523
 524 /**
 525  * uwb_rsv_destroy - free a UWB reservation structure
 526  * @rsv: the reservation to free
 527  *
 528  * The reservation must already be terminated.
 529  */
 530 void uwb_rsv_destroy(struct uwb_rsv *rsv)
 531 {
 532         uwb_rsv_put(rsv);
 533 }
 534 EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
 535
 536 /**
 537  * usb_rsv_establish - start a reservation establishment
 538  * @rsv: the reservation
 539  *
 540  * The PAL should fill in @rsv's owner, target, type, max_mas,
 541  * min_mas, max_interval and is_multicast fields.  If the target is a
 542  * uwb_dev it must be referenced.
 543  *
 544  * The reservation's callback will be called when the reservation is
 545  * accepted, denied or times out.
 546  */
 547 int uwb_rsv_establish(struct uwb_rsv *rsv)
 548 {
 549         struct uwb_rc *rc = rsv->rc;
 550         struct uwb_mas_bm available;
 551         int ret;
 552
 553         mutex_lock(&rc->rsvs_mutex);
 554         ret = uwb_rsv_get_stream(rsv);
 555         if (ret)
 556                 goto out;
 557
 558         rsv->tiebreaker = random32() & 1;
 559         /* get available mas bitmap */
 560         uwb_drp_available(rc, &available);
 561
 562         ret = uwb_rsv_find_best_allocation(rsv, &available, &rsv->mas);
 563         if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
 564                 ret = -EBUSY;
 565                 uwb_rsv_put_stream(rsv);
 566                 goto out;
 567         }
 568
 569         ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
 570         if (ret != 0) {
 571                 uwb_rsv_put_stream(rsv);
 572                 goto out;
 573         }
 574
 575         uwb_rsv_get(rsv);
 576         list_add_tail(&rsv->rc_node, &rc->reservations);
 577         rsv->owner = &rc->uwb_dev;
 578         uwb_dev_get(rsv->owner);
 579         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
 580 out:
 581         mutex_unlock(&rc->rsvs_mutex);
 582         return ret;
 583 }
 584 EXPORT_SYMBOL_GPL(uwb_rsv_establish);
 585
 586 /**
 587  * uwb_rsv_modify - modify an already established reservation
 588  * @rsv: the reservation to modify
 589  * @max_mas: new maximum MAS to reserve
 590  * @min_mas: new minimum MAS to reserve
 591  * @max_interval: new max_interval to use
 592  *
 593  * FIXME: implement this once there are PALs that use it.
 594  */
 595 int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int max_interval)
 596 {
 597         return -ENOSYS;
 598 }
 599 EXPORT_SYMBOL_GPL(uwb_rsv_modify);
 600
 601 /*
 602  * move an already established reservation (rc->rsvs_mutex must to be
 603  * taken when tis function is called)
 604  */
 605 int uwb_rsv_try_move(struct uwb_rsv *rsv, struct uwb_mas_bm *available)
 606 {
 607         struct uwb_rc *rc = rsv->rc;
 608         struct uwb_drp_backoff_win *bow = &rc->bow;
 609         struct device *dev = &rc->uwb_dev.dev;
 610         struct uwb_rsv_move *mv;
 611         int ret = 0;
 612
 613         if (bow->can_reserve_extra_mases == false)
 614                 return -EBUSY;
 615
 616         mv = &rsv->mv;
 617
 618         if (uwb_rsv_find_best_allocation(rsv, available, &mv->final_mas) == UWB_RSV_ALLOC_FOUND) {
 619
 620                 if (!bitmap_equal(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS)) {
 621                         /* We want to move the reservation */
 622                         bitmap_andnot(mv->companion_mas.bm, mv->final_mas.bm, rsv->mas.bm, UWB_NUM_MAS);
 623                         uwb_drp_avail_reserve_pending(rc, &mv->companion_mas);
 624                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
 625                 }
 626         } else {
 627                 dev_dbg(dev, "new allocation not found\n");
 628         }
 629
 630         return ret;
 631 }
 632
 633 /* It will try to move every reservation in state O_ESTABLISHED giving
 634  * to the MAS allocator algorithm an availability that is the real one
 635  * plus the allocation already established from the reservation. */
 636 void uwb_rsv_handle_drp_avail_change(struct uwb_rc *rc)
 637 {
 638         struct uwb_drp_backoff_win *bow = &rc->bow;
 639         struct uwb_rsv *rsv;
 640         struct uwb_mas_bm mas;
 641
 642         if (bow->can_reserve_extra_mases == false)
 643                 return;
 644
 645         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 646                 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED ||
 647                     rsv->state == UWB_RSV_STATE_O_TO_BE_MOVED) {
 648                         uwb_drp_available(rc, &mas);
 649                         bitmap_or(mas.bm, mas.bm, rsv->mas.bm, UWB_NUM_MAS);
 650                         uwb_rsv_try_move(rsv, &mas);
 651                 }
 652         }
 653
 654 }
 655
 656 /**
 657  * uwb_rsv_terminate - terminate an established reservation
 658  * @rsv: the reservation to terminate
 659  *
 660  * A reservation is terminated by removing the DRP IE from the beacon,
 661  * the other end will consider the reservation to be terminated when
 662  * it does not see the DRP IE for at least mMaxLostBeacons.
 663  *
 664  * If applicable, the reference to the target uwb_dev will be released.
 665  */
 666 void uwb_rsv_terminate(struct uwb_rsv *rsv)
 667 {
 668         struct uwb_rc *rc = rsv->rc;
 669
 670         mutex_lock(&rc->rsvs_mutex);
 671
 672         if (rsv->state != UWB_RSV_STATE_NONE)
 673                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
 674
 675         mutex_unlock(&rc->rsvs_mutex);
 676 }
 677 EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
 678
 679 /**
 680  * uwb_rsv_accept - accept a new reservation from a peer
 681  * @rsv:      the reservation
 682  * @cb:       call back for reservation changes
 683  * @pal_priv: data to be passed in the above call back
 684  *
 685  * Reservation requests from peers are denied unless a PAL accepts it
 686  * by calling this function.
 687  *
 688  * The PAL call uwb_rsv_destroy() for all accepted reservations before
 689  * calling uwb_pal_unregister().
 690  */
 691 void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
 692 {
 693         uwb_rsv_get(rsv);
 694
 695         rsv->callback = cb;
 696         rsv->pal_priv = pal_priv;
 697         rsv->state    = UWB_RSV_STATE_T_ACCEPTED;
 698 }
 699 EXPORT_SYMBOL_GPL(uwb_rsv_accept);
 700
 701 /*
 702  * Is a received DRP IE for this reservation?
 703  */
 704 static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
 705                           struct uwb_ie_drp *drp_ie)
 706 {
 707         struct uwb_dev_addr *rsv_src;
 708         int stream;
 709
 710         stream = uwb_ie_drp_stream_index(drp_ie);
 711
 712         if (rsv->stream != stream)
 713                 return false;
 714
 715         switch (rsv->target.type) {
 716         case UWB_RSV_TARGET_DEVADDR:
 717                 return rsv->stream == stream;
 718         case UWB_RSV_TARGET_DEV:
 719                 if (uwb_ie_drp_owner(drp_ie))
 720                         rsv_src = &rsv->owner->dev_addr;
 721                 else
 722                         rsv_src = &rsv->target.dev->dev_addr;
 723                 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
 724         }
 725         return false;
 726 }
 727
 728 static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
 729                                           struct uwb_dev *src,
 730                                           struct uwb_ie_drp *drp_ie)
 731 {
 732         struct uwb_rsv *rsv;
 733         struct uwb_pal *pal;
 734         enum uwb_rsv_state state;
 735
 736         rsv = uwb_rsv_alloc(rc);
 737         if (!rsv)
 738                 return NULL;
 739
 740         rsv->rc          = rc;
 741         rsv->owner       = src;
 742         uwb_dev_get(rsv->owner);
 743         rsv->target.type = UWB_RSV_TARGET_DEV;
 744         rsv->target.dev  = &rc->uwb_dev;
 745         uwb_dev_get(&rc->uwb_dev);
 746         rsv->type        = uwb_ie_drp_type(drp_ie);
 747         rsv->stream      = uwb_ie_drp_stream_index(drp_ie);
 748         uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
 749
 750         /*
 751          * See if any PALs are interested in this reservation. If not,
 752          * deny the request.
 753          */
 754         rsv->state = UWB_RSV_STATE_T_DENIED;
 755         mutex_lock(&rc->uwb_dev.mutex);
 756         list_for_each_entry(pal, &rc->pals, node) {
 757                 if (pal->new_rsv)
 758                         pal->new_rsv(pal, rsv);
 759                 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
 760                         break;
 761         }
 762         mutex_unlock(&rc->uwb_dev.mutex);
 763
 764         list_add_tail(&rsv->rc_node, &rc->reservations);
 765         state = rsv->state;
 766         rsv->state = UWB_RSV_STATE_NONE;
 767
 768         /* FIXME: do something sensible here */
 769         if (state == UWB_RSV_STATE_T_ACCEPTED
 770             && uwb_drp_avail_reserve_pending(rc, &rsv->mas) == -EBUSY) {
 771                 /* FIXME: do something sensible here */
 772         } else {
 773                 uwb_rsv_set_state(rsv, state);
 774         }
 775
 776         return rsv;
 777 }
 778
 779 /**
 780  * uwb_rsv_get_usable_mas - get the bitmap of the usable MAS of a reservations
 781  * @rsv: the reservation.
 782  * @mas: returns the available MAS.
 783  *
 784  * The usable MAS of a reservation may be less than the negotiated MAS
 785  * if alien BPs are present.
 786  */
 787 void uwb_rsv_get_usable_mas(struct uwb_rsv *rsv, struct uwb_mas_bm *mas)
 788 {
 789         bitmap_zero(mas->bm, UWB_NUM_MAS);
 790         bitmap_andnot(mas->bm, rsv->mas.bm, rsv->rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
 791 }
 792 EXPORT_SYMBOL_GPL(uwb_rsv_get_usable_mas);
 793
 794 /**
 795  * uwb_rsv_find - find a reservation for a received DRP IE.
 796  * @rc: the radio controller
 797  * @src: source of the DRP IE
 798  * @drp_ie: the DRP IE
 799  *
 800  * If the reservation cannot be found and the DRP IE is from a peer
 801  * attempting to establish a new reservation, create a new reservation
 802  * and add it to the list.
 803  */
 804 struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
 805                              struct uwb_ie_drp *drp_ie)
 806 {
 807         struct uwb_rsv *rsv;
 808
 809         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 810                 if (uwb_rsv_match(rsv, src, drp_ie))
 811                         return rsv;
 812         }
 813
 814         if (uwb_ie_drp_owner(drp_ie))
 815                 return uwb_rsv_new_target(rc, src, drp_ie);
 816
 817         return NULL;
 818 }
 819
 820 /*
 821  * Go through all the reservations and check for timeouts and (if
 822  * necessary) update their DRP IEs.
 823  *
 824  * FIXME: look at building the SET_DRP_IE command here rather than
 825  * having to rescan the list in uwb_rc_send_all_drp_ie().
 826  */
 827 static bool uwb_rsv_update_all(struct uwb_rc *rc)
 828 {
 829         struct uwb_rsv *rsv, *t;
 830         bool ie_updated = false;
 831
 832         list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
 833                 if (!rsv->ie_valid) {
 834                         uwb_drp_ie_update(rsv);
 835                         ie_updated = true;
 836                 }
 837         }
 838
 839         return ie_updated;
 840 }
 841
 842 void uwb_rsv_queue_update(struct uwb_rc *rc)
 843 {
 844         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
 845
 846         queue_delayed_work(rc->rsv_workq, &rc->rsv_update_work, usecs_to_jiffies(delay_us));
 847 }
 848
 849 /**
 850  * uwb_rsv_sched_update - schedule an update of the DRP IEs
 851  * @rc: the radio controller.
 852  *
 853  * To improve performance and ensure correctness with [ECMA-368] the
 854  * number of SET-DRP-IE commands that are done are limited.
 855  *
 856  * DRP IEs update come from two sources: DRP events from the hardware
 857  * which all occur at the beginning of the superframe ('syncronous'
 858  * events) and reservation establishment/termination requests from
 859  * PALs or timers ('asynchronous' events).
 860  *
 861  * A delayed work ensures that all the synchronous events result in
 862  * one SET-DRP-IE command.
 863  *
 864  * Additional logic (the set_drp_ie_pending and rsv_updated_postponed
 865  * flags) will prevent an asynchrous event starting a SET-DRP-IE
 866  * command if one is currently awaiting a response.
 867  *
 868  * FIXME: this does leave a window where an asynchrous event can delay
 869  * the SET-DRP-IE for a synchronous event by one superframe.
 870  */
 871 void uwb_rsv_sched_update(struct uwb_rc *rc)
 872 {
 873         spin_lock_bh(&rc->rsvs_lock);
 874         if (!delayed_work_pending(&rc->rsv_update_work)) {
 875                 if (rc->set_drp_ie_pending > 0) {
 876                         rc->set_drp_ie_pending++;
 877                         goto unlock;
 878                 }
 879                 uwb_rsv_queue_update(rc);
 880         }
 881 unlock:
 882         spin_unlock_bh(&rc->rsvs_lock);
 883 }
 884
 885 /*
 886  * Update DRP IEs and, if necessary, the DRP Availability IE and send
 887  * the updated IEs to the radio controller.
 888  */
 889 static void uwb_rsv_update_work(struct work_struct *work)
 890 {
 891         struct uwb_rc *rc = container_of(work, struct uwb_rc,
 892                                          rsv_update_work.work);
 893         bool ie_updated;
 894
 895         mutex_lock(&rc->rsvs_mutex);
 896
 897         ie_updated = uwb_rsv_update_all(rc);
 898
 899         if (!rc->drp_avail.ie_valid) {
 900                 uwb_drp_avail_ie_update(rc);
 901                 ie_updated = true;
 902         }
 903
 904         if (ie_updated && (rc->set_drp_ie_pending == 0))
 905                 uwb_rc_send_all_drp_ie(rc);
 906
 907         mutex_unlock(&rc->rsvs_mutex);
 908 }
 909
 910 static void uwb_rsv_alien_bp_work(struct work_struct *work)
 911 {
 912         struct uwb_rc *rc = container_of(work, struct uwb_rc,
 913                                          rsv_alien_bp_work.work);
 914         struct uwb_rsv *rsv;
 915
 916         mutex_lock(&rc->rsvs_mutex);
 917
 918         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 919                 if (rsv->type != UWB_DRP_TYPE_ALIEN_BP) {
 920                         rsv->callback(rsv);
 921                 }
 922         }
 923
 924         mutex_unlock(&rc->rsvs_mutex);
 925 }
 926
 927 static void uwb_rsv_timer(unsigned long arg)
 928 {
 929         struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
 930
 931         queue_work(rsv->rc->rsv_workq, &rsv->handle_timeout_work);
 932 }
 933
 934 /**
 935  * uwb_rsv_remove_all - remove all reservations
 936  * @rc: the radio controller
 937  *
 938  * A DRP IE update is not done.
 939  */
 940 void uwb_rsv_remove_all(struct uwb_rc *rc)
 941 {
 942         struct uwb_rsv *rsv, *t;
 943
 944         mutex_lock(&rc->rsvs_mutex);
 945         list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
 946                 if (rsv->state != UWB_RSV_STATE_NONE)
 947                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
 948                 del_timer_sync(&rsv->timer);
 949         }
 950         /* Cancel any postponed update. */
 951         rc->set_drp_ie_pending = 0;
 952         mutex_unlock(&rc->rsvs_mutex);
 953
 954         cancel_delayed_work_sync(&rc->rsv_update_work);
 955         flush_workqueue(rc->rsv_workq);
 956
 957         mutex_lock(&rc->rsvs_mutex);
 958         list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
 959                 uwb_rsv_remove(rsv);
 960         }
 961         mutex_unlock(&rc->rsvs_mutex);
 962 }
 963
 964 void uwb_rsv_init(struct uwb_rc *rc)
 965 {
 966         INIT_LIST_HEAD(&rc->reservations);
 967         INIT_LIST_HEAD(&rc->cnflt_alien_list);
 968         mutex_init(&rc->rsvs_mutex);
 969         spin_lock_init(&rc->rsvs_lock);
 970         INIT_DELAYED_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
 971         INIT_DELAYED_WORK(&rc->rsv_alien_bp_work, uwb_rsv_alien_bp_work);
 972         rc->bow.can_reserve_extra_mases = true;
 973         rc->bow.total_expired = 0;
 974         rc->bow.window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
 975         init_timer(&rc->bow.timer);
 976         rc->bow.timer.function = uwb_rsv_backoff_win_timer;
 977         rc->bow.timer.data     = (unsigned long)&rc->bow;
 978
 979         bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
 980 }
 981
 982 int uwb_rsv_setup(struct uwb_rc *rc)
 983 {
 984         char name[16];
 985
 986         snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
 987         rc->rsv_workq = create_singlethread_workqueue(name);
 988         if (rc->rsv_workq == NULL)
 989                 return -ENOMEM;
 990
 991         return 0;
 992 }
 993
 994 void uwb_rsv_cleanup(struct uwb_rc *rc)
 995 {
 996         uwb_rsv_remove_all(rc);
 997         destroy_workqueue(rc->rsv_workq);
 998 }