drivers/uwb/drp.c

   1 /*
   2  * Ultra Wide Band
   3  * Dynamic Reservation Protocol handling
   4  *
   5  * Copyright (C) 2005-2006 Intel Corporation
   6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   7  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License version
  11  * 2 as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21 #include <linux/kthread.h>
  22 #include <linux/freezer.h>
  23 #include <linux/slab.h>
  24 #include <linux/delay.h>
  25 #include "uwb-internal.h"
  26
  27
  28 /* DRP Conflict Actions ([ECMA-368 2nd Edition] 17.4.6) */
  29 enum uwb_drp_conflict_action {
  30         /* Reservation is maintained, no action needed */
  31         UWB_DRP_CONFLICT_MANTAIN = 0,
  32
  33         /* the device shall not transmit frames in conflicting MASs in
  34          * the following superframe. If the device is the reservation
  35          * target, it shall also set the Reason Code in its DRP IE to
  36          * Conflict in its beacon in the following superframe.
  37          */
  38         UWB_DRP_CONFLICT_ACT1,
  39
  40         /* the device shall not set the Reservation Status bit to ONE
  41          * and shall not transmit frames in conflicting MASs. If the
  42          * device is the reservation target, it shall also set the
  43          * Reason Code in its DRP IE to Conflict.
  44          */
  45         UWB_DRP_CONFLICT_ACT2,
  46
  47         /* the device shall not transmit frames in conflicting MASs in
  48          * the following superframe. It shall remove the conflicting
  49          * MASs from the reservation or set the Reservation Status to
  50          * ZERO in its beacon in the following superframe. If the
  51          * device is the reservation target, it shall also set the
  52          * Reason Code in its DRP IE to Conflict.
  53          */
  54         UWB_DRP_CONFLICT_ACT3,
  55 };
  56
  57
  58 static void uwb_rc_set_drp_cmd_done(struct uwb_rc *rc, void *arg,
  59                                     struct uwb_rceb *reply, ssize_t reply_size)
  60 {
  61         struct uwb_rc_evt_set_drp_ie *r = (struct uwb_rc_evt_set_drp_ie *)reply;
  62
  63         if (r != NULL) {
  64                 if (r->bResultCode != UWB_RC_RES_SUCCESS)
  65                         dev_err(&rc->uwb_dev.dev, "SET-DRP-IE failed: %s (%d)\n",
  66                                 uwb_rc_strerror(r->bResultCode), r->bResultCode);
  67         } else
  68                 dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: timeout\n");
  69
  70         spin_lock_bh(&rc->rsvs_lock);
  71         if (rc->set_drp_ie_pending > 1) {
  72                 rc->set_drp_ie_pending = 0;
  73                 uwb_rsv_queue_update(rc);
  74         } else {
  75                 rc->set_drp_ie_pending = 0;
  76         }
  77         spin_unlock_bh(&rc->rsvs_lock);
  78 }
  79
  80 /**
  81  * Construct and send the SET DRP IE
  82  *
  83  * @rc:         UWB Host controller
  84  * @returns:    >= 0 number of bytes still available in the beacon
  85  *              < 0 errno code on error.
  86  *
  87  * See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
  88  * device to include in its beacon at the same time. We thus have to
  89  * traverse all reservations and include the DRP IEs of all PENDING
  90  * and NEGOTIATED reservations in a SET DRP command for transmission.
  91  *
  92  * A DRP Availability IE is appended.
  93  *
  94  * rc->rsvs_mutex is held
  95  *
  96  * FIXME We currently ignore the returned value indicating the remaining space
  97  * in beacon. This could be used to deny reservation requests earlier if
  98  * determined that they would cause the beacon space to be exceeded.
  99  */
 100 int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
 101 {
 102         int result;
 103         struct uwb_rc_cmd_set_drp_ie *cmd;
 104         struct uwb_rsv *rsv;
 105         struct uwb_rsv_move *mv;
 106         int num_bytes = 0;
 107         u8 *IEDataptr;
 108
 109         result = -ENOMEM;
 110         /* First traverse all reservations to determine memory needed. */
 111         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 112                 if (rsv->drp_ie != NULL) {
 113                         num_bytes += rsv->drp_ie->hdr.length + 2;
 114                         if (uwb_rsv_has_two_drp_ies(rsv) &&
 115                                 (rsv->mv.companion_drp_ie != NULL)) {
 116                                 mv = &rsv->mv;
 117                                 num_bytes += mv->companion_drp_ie->hdr.length + 2;
 118                         }
 119                 }
 120         }
 121         num_bytes += sizeof(rc->drp_avail.ie);
 122         cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
 123         if (cmd == NULL)
 124                 goto error;
 125         cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
 126         cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
 127         cmd->wIELength = num_bytes;
 128         IEDataptr = (u8 *)&cmd->IEData[0];
 129
 130         /* FIXME: DRV avail IE is not always needed */
 131         /* put DRP avail IE first */
 132         memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));
 133         IEDataptr += sizeof(struct uwb_ie_drp_avail);
 134
 135         /* Next traverse all reservations to place IEs in allocated memory. */
 136         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 137                 if (rsv->drp_ie != NULL) {
 138                         memcpy(IEDataptr, rsv->drp_ie,
 139                                rsv->drp_ie->hdr.length + 2);
 140                         IEDataptr += rsv->drp_ie->hdr.length + 2;
 141
 142                         if (uwb_rsv_has_two_drp_ies(rsv) &&
 143                                 (rsv->mv.companion_drp_ie != NULL)) {
 144                                 mv = &rsv->mv;
 145                                 memcpy(IEDataptr, mv->companion_drp_ie,
 146                                        mv->companion_drp_ie->hdr.length + 2);
 147                                 IEDataptr += mv->companion_drp_ie->hdr.length + 2;
 148                         }
 149                 }
 150         }
 151
 152         result = uwb_rc_cmd_async(rc, "SET-DRP-IE", &cmd->rccb, sizeof(*cmd) + num_bytes,
 153                                   UWB_RC_CET_GENERAL, UWB_RC_CMD_SET_DRP_IE,
 154                                   uwb_rc_set_drp_cmd_done, NULL);
 155
 156         rc->set_drp_ie_pending = 1;
 157
 158         kfree(cmd);
 159 error:
 160         return result;
 161 }
 162
 163 /*
 164  * Evaluate the action to perform using conflict resolution rules
 165  *
 166  * Return a uwb_drp_conflict_action.
 167  */
 168 static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beacon_slot,
 169                                     struct uwb_rsv *rsv, int our_status)
 170 {
 171         int our_tie_breaker = rsv->tiebreaker;
 172         int our_type        = rsv->type;
 173         int our_beacon_slot = rsv->rc->uwb_dev.beacon_slot;
 174
 175         int ext_tie_breaker = uwb_ie_drp_tiebreaker(ext_drp_ie);
 176         int ext_status      = uwb_ie_drp_status(ext_drp_ie);
 177         int ext_type        = uwb_ie_drp_type(ext_drp_ie);
 178
 179
 180         /* [ECMA-368 2nd Edition] 17.4.6 */
 181         if (ext_type == UWB_DRP_TYPE_PCA && our_type == UWB_DRP_TYPE_PCA) {
 182                 return UWB_DRP_CONFLICT_MANTAIN;
 183         }
 184
 185         /* [ECMA-368 2nd Edition] 17.4.6-1 */
 186         if (our_type == UWB_DRP_TYPE_ALIEN_BP) {
 187                 return UWB_DRP_CONFLICT_MANTAIN;
 188         }
 189
 190         /* [ECMA-368 2nd Edition] 17.4.6-2 */
 191         if (ext_type == UWB_DRP_TYPE_ALIEN_BP) {
 192                 /* here we know our_type != UWB_DRP_TYPE_ALIEN_BP */
 193                 return UWB_DRP_CONFLICT_ACT1;
 194         }
 195
 196         /* [ECMA-368 2nd Edition] 17.4.6-3 */
 197         if (our_status == 0 && ext_status == 1) {
 198                 return UWB_DRP_CONFLICT_ACT2;
 199         }
 200
 201         /* [ECMA-368 2nd Edition] 17.4.6-4 */
 202         if (our_status == 1 && ext_status == 0) {
 203                 return UWB_DRP_CONFLICT_MANTAIN;
 204         }
 205
 206         /* [ECMA-368 2nd Edition] 17.4.6-5a */
 207         if (our_tie_breaker == ext_tie_breaker &&
 208             our_beacon_slot <  ext_beacon_slot) {
 209                 return UWB_DRP_CONFLICT_MANTAIN;
 210         }
 211
 212         /* [ECMA-368 2nd Edition] 17.4.6-5b */
 213         if (our_tie_breaker != ext_tie_breaker &&
 214             our_beacon_slot >  ext_beacon_slot) {
 215                 return UWB_DRP_CONFLICT_MANTAIN;
 216         }
 217
 218         if (our_status == 0) {
 219                 if (our_tie_breaker == ext_tie_breaker) {
 220                         /* [ECMA-368 2nd Edition] 17.4.6-6a */
 221                         if (our_beacon_slot > ext_beacon_slot) {
 222                                 return UWB_DRP_CONFLICT_ACT2;
 223                         }
 224                 } else  {
 225                         /* [ECMA-368 2nd Edition] 17.4.6-6b */
 226                         if (our_beacon_slot < ext_beacon_slot) {
 227                                 return UWB_DRP_CONFLICT_ACT2;
 228                         }
 229                 }
 230         } else {
 231                 if (our_tie_breaker == ext_tie_breaker) {
 232                         /* [ECMA-368 2nd Edition] 17.4.6-7a */
 233                         if (our_beacon_slot > ext_beacon_slot) {
 234                                 return UWB_DRP_CONFLICT_ACT3;
 235                         }
 236                 } else {
 237                         /* [ECMA-368 2nd Edition] 17.4.6-7b */
 238                         if (our_beacon_slot < ext_beacon_slot) {
 239                                 return UWB_DRP_CONFLICT_ACT3;
 240                         }
 241                 }
 242         }
 243         return UWB_DRP_CONFLICT_MANTAIN;
 244 }
 245
 246 static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
 247                                    int ext_beacon_slot,
 248                                    struct uwb_rsv *rsv,
 249                                    struct uwb_mas_bm *conflicting_mas)
 250 {
 251         struct uwb_rc *rc = rsv->rc;
 252         struct uwb_rsv_move *mv = &rsv->mv;
 253         struct uwb_drp_backoff_win *bow = &rc->bow;
 254         int action;
 255
 256         action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, uwb_rsv_status(rsv));
 257
 258         if (uwb_rsv_is_owner(rsv)) {
 259                 switch(action) {
 260                 case UWB_DRP_CONFLICT_ACT2:
 261                         /* try move */
 262                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_TO_BE_MOVED);
 263                         if (bow->can_reserve_extra_mases == false)
 264                                 uwb_rsv_backoff_win_increment(rc);
 265
 266                         break;
 267                 case UWB_DRP_CONFLICT_ACT3:
 268                         uwb_rsv_backoff_win_increment(rc);
 269                         /* drop some mases with reason modified */
 270                         /* put in the companion the mases to be dropped */
 271                         bitmap_and(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
 272                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
 273                 default:
 274                         break;
 275                 }
 276         } else {
 277                 switch(action) {
 278                 case UWB_DRP_CONFLICT_ACT2:
 279                 case UWB_DRP_CONFLICT_ACT3:
 280                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
 281                 default:
 282                         break;
 283                 }
 284
 285         }
 286
 287 }
 288
 289 static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_slot,
 290                                       struct uwb_rsv *rsv, bool companion_only,
 291                                       struct uwb_mas_bm *conflicting_mas)
 292 {
 293         struct uwb_rc *rc = rsv->rc;
 294         struct uwb_drp_backoff_win *bow = &rc->bow;
 295         struct uwb_rsv_move *mv = &rsv->mv;
 296         int action;
 297
 298         if (companion_only) {
 299                 /* status of companion is 0 at this point */
 300                 action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, 0);
 301                 if (uwb_rsv_is_owner(rsv)) {
 302                         switch(action) {
 303                         case UWB_DRP_CONFLICT_ACT2:
 304                         case UWB_DRP_CONFLICT_ACT3:
 305                                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 306                                 rsv->needs_release_companion_mas = false;
 307                                 if (bow->can_reserve_extra_mases == false)
 308                                         uwb_rsv_backoff_win_increment(rc);
 309                                 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
 310                         }
 311                 } else { /* rsv is target */
 312                         switch(action) {
 313                         case UWB_DRP_CONFLICT_ACT2:
 314                         case UWB_DRP_CONFLICT_ACT3:
 315                                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_CONFLICT);
 316                                 /* send_drp_avail_ie = true; */
 317                         }
 318                 }
 319         } else { /* also base part of the reservation is conflicting */
 320                 if (uwb_rsv_is_owner(rsv)) {
 321                         uwb_rsv_backoff_win_increment(rc);
 322                         /* remove companion part */
 323                         uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
 324
 325                         /* drop some mases with reason modified */
 326
 327                         /* put in the companion the mases to be dropped */
 328                         bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
 329                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
 330                 } else { /* it is a target rsv */
 331                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
 332                         /* send_drp_avail_ie = true; */
 333                 }
 334         }
 335 }
 336
 337 static void uwb_drp_handle_conflict_rsv(struct uwb_rc *rc, struct uwb_rsv *rsv,
 338                                         struct uwb_rc_evt_drp *drp_evt,
 339                                         struct uwb_ie_drp *drp_ie,
 340                                         struct uwb_mas_bm *conflicting_mas)
 341 {
 342         struct uwb_rsv_move *mv;
 343
 344         /* check if the conflicting reservation has two drp_ies */
 345         if (uwb_rsv_has_two_drp_ies(rsv)) {
 346                 mv = &rsv->mv;
 347                 if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
 348                         handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
 349                                                   rsv, false, conflicting_mas);
 350                 } else {
 351                         if (bitmap_intersects(mv->companion_mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
 352                                 handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
 353                                                           rsv, true, conflicting_mas);
 354                         }
 355                 }
 356         } else if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
 357                 handle_conflict_normal(drp_ie, drp_evt->beacon_slot_number, rsv, conflicting_mas);
 358         }
 359 }
 360
 361 static void uwb_drp_handle_all_conflict_rsv(struct uwb_rc *rc,
 362                                             struct uwb_rc_evt_drp *drp_evt,
 363                                             struct uwb_ie_drp *drp_ie,
 364                                             struct uwb_mas_bm *conflicting_mas)
 365 {
 366         struct uwb_rsv *rsv;
 367
 368         list_for_each_entry(rsv, &rc->reservations, rc_node) {
 369                 uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, conflicting_mas);
 370         }
 371 }
 372
 373 /*
 374  * Based on the DRP IE, transition a target reservation to a new
 375  * state.
 376  */
 377 static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
 378                                    struct uwb_ie_drp *drp_ie, struct uwb_rc_evt_drp *drp_evt)
 379 {
 380         struct device *dev = &rc->uwb_dev.dev;
 381         struct uwb_rsv_move *mv = &rsv->mv;
 382         int status;
 383         enum uwb_drp_reason reason_code;
 384         struct uwb_mas_bm mas;
 385
 386         status = uwb_ie_drp_status(drp_ie);
 387         reason_code = uwb_ie_drp_reason_code(drp_ie);
 388         uwb_drp_ie_to_bm(&mas, drp_ie);
 389
 390         switch (reason_code) {
 391         case UWB_DRP_REASON_ACCEPTED:
 392
 393                 if (rsv->state == UWB_RSV_STATE_T_CONFLICT) {
 394                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
 395                         break;
 396                 }
 397
 398                 if (rsv->state == UWB_RSV_STATE_T_EXPANDING_ACCEPTED) {
 399                         /* drp_ie is companion */
 400                         if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS))
 401                                 /* stroke companion */
 402                                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
 403                 } else {
 404                         if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
 405                                 if (uwb_drp_avail_reserve_pending(rc, &mas) == -EBUSY) {
 406                                         /* FIXME: there is a conflict, find
 407                                          * the conflicting reservations and
 408                                          * take a sensible action. Consider
 409                                          * that in drp_ie there is the
 410                                          * "neighbour" */
 411                                         uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
 412                                 } else {
 413                                         /* accept the extra reservation */
 414                                         bitmap_copy(mv->companion_mas.bm, mas.bm, UWB_NUM_MAS);
 415                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
 416                                 }
 417                         } else {
 418                                 if (status) {
 419                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
 420                                 }
 421                         }
 422
 423                 }
 424                 break;
 425
 426         case UWB_DRP_REASON_MODIFIED:
 427                 /* check to see if we have already modified the reservation */
 428                 if (bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
 429                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
 430                         break;
 431                 }
 432
 433                 /* find if the owner wants to expand or reduce */
 434                 if (bitmap_subset(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
 435                         /* owner is reducing */
 436                         bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mas.bm, UWB_NUM_MAS);
 437                         uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
 438                 }
 439
 440                 bitmap_copy(rsv->mas.bm, mas.bm, UWB_NUM_MAS);
 441                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_RESIZED);
 442                 break;
 443         default:
 444                 dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
 445                          reason_code, status);
 446         }
 447 }
 448
 449 /*
 450  * Based on the DRP IE, transition an owner reservation to a new
 451  * state.
 452  */
 453 static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
 454                                   struct uwb_dev *src, struct uwb_ie_drp *drp_ie,
 455                                   struct uwb_rc_evt_drp *drp_evt)
 456 {
 457         struct device *dev = &rc->uwb_dev.dev;
 458         struct uwb_rsv_move *mv = &rsv->mv;
 459         int status;
 460         enum uwb_drp_reason reason_code;
 461         struct uwb_mas_bm mas;
 462
 463         status = uwb_ie_drp_status(drp_ie);
 464         reason_code = uwb_ie_drp_reason_code(drp_ie);
 465         uwb_drp_ie_to_bm(&mas, drp_ie);
 466
 467         if (status) {
 468                 switch (reason_code) {
 469                 case UWB_DRP_REASON_ACCEPTED:
 470                         switch (rsv->state) {
 471                         case UWB_RSV_STATE_O_PENDING:
 472                         case UWB_RSV_STATE_O_INITIATED:
 473                         case UWB_RSV_STATE_O_ESTABLISHED:
 474                                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 475                                 break;
 476                         case UWB_RSV_STATE_O_MODIFIED:
 477                                 if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
 478                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 479                                 } else {
 480                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
 481                                 }
 482                                 break;
 483
 484                         case UWB_RSV_STATE_O_MOVE_REDUCING: /* shouldn' t be a problem */
 485                                 if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
 486                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
 487                                 } else {
 488                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
 489                                 }
 490                                 break;
 491                         case UWB_RSV_STATE_O_MOVE_EXPANDING:
 492                                 if (bitmap_equal(mas.bm, mv->companion_mas.bm, UWB_NUM_MAS)) {
 493                                         /* Companion reservation accepted */
 494                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
 495                                 } else {
 496                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
 497                                 }
 498                                 break;
 499                         case UWB_RSV_STATE_O_MOVE_COMBINING:
 500                                 if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS))
 501                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
 502                                 else
 503                                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
 504                                 break;
 505                         default:
 506                                 break;
 507                         }
 508                         break;
 509                 default:
 510                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
 511                                  reason_code, status);
 512                 }
 513         } else {
 514                 switch (reason_code) {
 515                 case UWB_DRP_REASON_PENDING:
 516                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
 517                         break;
 518                 case UWB_DRP_REASON_DENIED:
 519                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
 520                         break;
 521                 case UWB_DRP_REASON_CONFLICT:
 522                         /* resolve the conflict */
 523                         bitmap_complement(mas.bm, src->last_availability_bm,
 524                                           UWB_NUM_MAS);
 525                         uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, &mas);
 526                         break;
 527                 default:
 528                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
 529                                  reason_code, status);
 530                 }
 531         }
 532 }
 533
 534 static void uwb_cnflt_alien_stroke_timer(struct uwb_cnflt_alien *cnflt)
 535 {
 536         unsigned timeout_us = UWB_MAX_LOST_BEACONS * UWB_SUPERFRAME_LENGTH_US;
 537         mod_timer(&cnflt->timer, jiffies + usecs_to_jiffies(timeout_us));
 538 }
 539
 540 static void uwb_cnflt_update_work(struct work_struct *work)
 541 {
 542         struct uwb_cnflt_alien *cnflt = container_of(work,
 543                                                      struct uwb_cnflt_alien,
 544                                                      cnflt_update_work);
 545         struct uwb_cnflt_alien *c;
 546         struct uwb_rc *rc = cnflt->rc;
 547
 548         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
 549
 550         mutex_lock(&rc->rsvs_mutex);
 551
 552         list_del(&cnflt->rc_node);
 553
 554         /* update rc global conflicting alien bitmap */
 555         bitmap_zero(rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
 556
 557         list_for_each_entry(c, &rc->cnflt_alien_list, rc_node) {
 558                 bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, c->mas.bm, UWB_NUM_MAS);
 559         }
 560
 561         queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
 562
 563         kfree(cnflt);
 564         mutex_unlock(&rc->rsvs_mutex);
 565 }
 566
 567 static void uwb_cnflt_timer(unsigned long arg)
 568 {
 569         struct uwb_cnflt_alien *cnflt = (struct uwb_cnflt_alien *)arg;
 570
 571         queue_work(cnflt->rc->rsv_workq, &cnflt->cnflt_update_work);
 572 }
 573
 574 /*
 575  * We have received an DRP_IE of type Alien BP and we need to make
 576  * sure we do not transmit in conflicting MASs.
 577  */
 578 static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
 579 {
 580         struct device *dev = &rc->uwb_dev.dev;
 581         struct uwb_mas_bm mas;
 582         struct uwb_cnflt_alien *cnflt;
 583         char buf[72];
 584         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
 585
 586         uwb_drp_ie_to_bm(&mas, drp_ie);
 587         bitmap_scnprintf(buf, sizeof(buf), mas.bm, UWB_NUM_MAS);
 588
 589         list_for_each_entry(cnflt, &rc->cnflt_alien_list, rc_node) {
 590                 if (bitmap_equal(cnflt->mas.bm, mas.bm, UWB_NUM_MAS)) {
 591                         /* Existing alien BP reservation conflicting
 592                          * bitmap, just reset the timer */
 593                         uwb_cnflt_alien_stroke_timer(cnflt);
 594                         return;
 595                 }
 596         }
 597
 598         /* New alien BP reservation conflicting bitmap */
 599
 600         /* alloc and initialize new uwb_cnflt_alien */
 601         cnflt = kzalloc(sizeof(struct uwb_cnflt_alien), GFP_KERNEL);
 602         if (!cnflt)
 603                 dev_err(dev, "failed to alloc uwb_cnflt_alien struct\n");
 604         INIT_LIST_HEAD(&cnflt->rc_node);
 605         init_timer(&cnflt->timer);
 606         cnflt->timer.function = uwb_cnflt_timer;
 607         cnflt->timer.data     = (unsigned long)cnflt;
 608
 609         cnflt->rc = rc;
 610         INIT_WORK(&cnflt->cnflt_update_work, uwb_cnflt_update_work);
 611
 612         bitmap_copy(cnflt->mas.bm, mas.bm, UWB_NUM_MAS);
 613
 614         list_add_tail(&cnflt->rc_node, &rc->cnflt_alien_list);
 615
 616         /* update rc global conflicting alien bitmap */
 617         bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, mas.bm, UWB_NUM_MAS);
 618
 619         queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
 620
 621         /* start the timer */
 622         uwb_cnflt_alien_stroke_timer(cnflt);
 623 }
 624
 625 static void uwb_drp_process_not_involved(struct uwb_rc *rc,
 626                                          struct uwb_rc_evt_drp *drp_evt,
 627                                          struct uwb_ie_drp *drp_ie)
 628 {
 629         struct uwb_mas_bm mas;
 630
 631         uwb_drp_ie_to_bm(&mas, drp_ie);
 632         uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
 633 }
 634
 635 static void uwb_drp_process_involved(struct uwb_rc *rc, struct uwb_dev *src,
 636                                      struct uwb_rc_evt_drp *drp_evt,
 637                                      struct uwb_ie_drp *drp_ie)
 638 {
 639         struct uwb_rsv *rsv;
 640
 641         rsv = uwb_rsv_find(rc, src, drp_ie);
 642         if (!rsv) {
 643                 /*
 644                  * No reservation? It's either for a recently
 645                  * terminated reservation; or the DRP IE couldn't be
 646                  * processed (e.g., an invalid IE or out of memory).
 647                  */
 648                 return;
 649         }
 650
 651         /*
 652          * Do nothing with DRP IEs for reservations that have been
 653          * terminated.
 654          */
 655         if (rsv->state == UWB_RSV_STATE_NONE) {
 656                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
 657                 return;
 658         }
 659
 660         if (uwb_ie_drp_owner(drp_ie))
 661                 uwb_drp_process_target(rc, rsv, drp_ie, drp_evt);
 662         else
 663                 uwb_drp_process_owner(rc, rsv, src, drp_ie, drp_evt);
 664
 665 }
 666
 667
 668 static bool uwb_drp_involves_us(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
 669 {
 670         return uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, &drp_ie->dev_addr) == 0;
 671 }
 672
 673 /*
 674  * Process a received DRP IE.
 675  */
 676 static void uwb_drp_process(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
 677                             struct uwb_dev *src, struct uwb_ie_drp *drp_ie)
 678 {
 679         if (uwb_ie_drp_type(drp_ie) == UWB_DRP_TYPE_ALIEN_BP)
 680                 uwb_drp_handle_alien_drp(rc, drp_ie);
 681         else if (uwb_drp_involves_us(rc, drp_ie))
 682                 uwb_drp_process_involved(rc, src, drp_evt, drp_ie);
 683         else
 684                 uwb_drp_process_not_involved(rc, drp_evt, drp_ie);
 685 }
 686
 687 /*
 688  * Process a received DRP Availability IE
 689  */
 690 static void uwb_drp_availability_process(struct uwb_rc *rc, struct uwb_dev *src,
 691                                          struct uwb_ie_drp_avail *drp_availability_ie)
 692 {
 693         bitmap_copy(src->last_availability_bm,
 694                     drp_availability_ie->bmp, UWB_NUM_MAS);
 695 }
 696
 697 /*
 698  * Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
 699  * from a device.
 700  */
 701 static
 702 void uwb_drp_process_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
 703                          size_t ielen, struct uwb_dev *src_dev)
 704 {
 705         struct device *dev = &rc->uwb_dev.dev;
 706         struct uwb_ie_hdr *ie_hdr;
 707         void *ptr;
 708
 709         ptr = drp_evt->ie_data;
 710         for (;;) {
 711                 ie_hdr = uwb_ie_next(&ptr, &ielen);
 712                 if (!ie_hdr)
 713                         break;
 714
 715                 switch (ie_hdr->element_id) {
 716                 case UWB_IE_DRP_AVAILABILITY:
 717                         uwb_drp_availability_process(rc, src_dev, (struct uwb_ie_drp_avail *)ie_hdr);
 718                         break;
 719                 case UWB_IE_DRP:
 720                         uwb_drp_process(rc, drp_evt, src_dev, (struct uwb_ie_drp *)ie_hdr);
 721                         break;
 722                 default:
 723                         dev_warn(dev, "unexpected IE in DRP notification\n");
 724                         break;
 725                 }
 726         }
 727
 728         if (ielen > 0)
 729                 dev_warn(dev, "%d octets remaining in DRP notification\n",
 730                          (int)ielen);
 731 }
 732
 733 /**
 734  * uwbd_evt_handle_rc_drp - handle a DRP_IE event
 735  * @evt: the DRP_IE event from the radio controller
 736  *
 737  * This processes DRP notifications from the radio controller, either
 738  * initiating a new reservation or transitioning an existing
 739  * reservation into a different state.
 740  *
 741  * DRP notifications can occur for three different reasons:
 742  *
 743  * - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
 744  *   the target or source have been received.
 745  *
 746  *   These DRP IEs could be new or for an existing reservation.
 747  *
 748  *   If the DRP IE for an existing reservation ceases to be to
 749  *   received for at least mMaxLostBeacons, the reservation should be
 750  *   considered to be terminated.  Note that the TERMINATE reason (see
 751  *   below) may not always be signalled (e.g., the remote device has
 752  *   two or more reservations established with the RC).
 753  *
 754  * - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
 755  *   group conflict with the RC's reservations.
 756  *
 757  * - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
 758  *   from a device (i.e., it's terminated all reservations).
 759  *
 760  * Only the software state of the reservations is changed; the setting
 761  * of the radio controller's DRP IEs is done after all the events in
 762  * an event buffer are processed.  This saves waiting multiple times
 763  * for the SET_DRP_IE command to complete.
 764  */
 765 int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
 766 {
 767         struct device *dev = &evt->rc->uwb_dev.dev;
 768         struct uwb_rc *rc = evt->rc;
 769         struct uwb_rc_evt_drp *drp_evt;
 770         size_t ielength, bytes_left;
 771         struct uwb_dev_addr src_addr;
 772         struct uwb_dev *src_dev;
 773
 774         /* Is there enough data to decode the event (and any IEs in
 775            its payload)? */
 776         if (evt->notif.size < sizeof(*drp_evt)) {
 777                 dev_err(dev, "DRP event: Not enough data to decode event "
 778                         "[%zu bytes left, %zu needed]\n",
 779                         evt->notif.size, sizeof(*drp_evt));
 780                 return 0;
 781         }
 782         bytes_left = evt->notif.size - sizeof(*drp_evt);
 783         drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
 784         ielength = le16_to_cpu(drp_evt->ie_length);
 785         if (bytes_left != ielength) {
 786                 dev_err(dev, "DRP event: Not enough data in payload [%zu"
 787                         "bytes left, %zu declared in the event]\n",
 788                         bytes_left, ielength);
 789                 return 0;
 790         }
 791
 792         memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
 793         src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
 794         if (!src_dev) {
 795                 /*
 796                  * A DRP notification from an unrecognized device.
 797                  *
 798                  * This is probably from a WUSB device that doesn't
 799                  * have an EUI-48 and therefore doesn't show up in the
 800                  * UWB device database.  It's safe to simply ignore
 801                  * these.
 802                  */
 803                 return 0;
 804         }
 805
 806         mutex_lock(&rc->rsvs_mutex);
 807
 808         /* We do not distinguish from the reason */
 809         uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
 810
 811         mutex_unlock(&rc->rsvs_mutex);
 812
 813         uwb_dev_put(src_dev);
 814         return 0;
 815 }