mirror of
https://github.com/torvalds/linux.git
synced 2024-12-09 04:31:39 +00:00
25985edced
Fixes generated by 'codespell' and manually reviewed. Signed-off-by: Lucas De Marchi <lucas.demarchi@profusion.mobi>
816 lines
24 KiB
C
816 lines
24 KiB
C
/*
|
|
* Ultra Wide Band
|
|
* Dynamic Reservation Protocol handling
|
|
*
|
|
* Copyright (C) 2005-2006 Intel Corporation
|
|
* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
|
|
* Copyright (C) 2008 Cambridge Silicon Radio Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License version
|
|
* 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <linux/kthread.h>
|
|
#include <linux/freezer.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
#include "uwb-internal.h"
|
|
|
|
|
|
/* DRP Conflict Actions ([ECMA-368 2nd Edition] 17.4.6) */
|
|
enum uwb_drp_conflict_action {
|
|
/* Reservation is maintained, no action needed */
|
|
UWB_DRP_CONFLICT_MANTAIN = 0,
|
|
|
|
/* the device shall not transmit frames in conflicting MASs in
|
|
* the following superframe. If the device is the reservation
|
|
* target, it shall also set the Reason Code in its DRP IE to
|
|
* Conflict in its beacon in the following superframe.
|
|
*/
|
|
UWB_DRP_CONFLICT_ACT1,
|
|
|
|
/* the device shall not set the Reservation Status bit to ONE
|
|
* and shall not transmit frames in conflicting MASs. If the
|
|
* device is the reservation target, it shall also set the
|
|
* Reason Code in its DRP IE to Conflict.
|
|
*/
|
|
UWB_DRP_CONFLICT_ACT2,
|
|
|
|
/* the device shall not transmit frames in conflicting MASs in
|
|
* the following superframe. It shall remove the conflicting
|
|
* MASs from the reservation or set the Reservation Status to
|
|
* ZERO in its beacon in the following superframe. If the
|
|
* device is the reservation target, it shall also set the
|
|
* Reason Code in its DRP IE to Conflict.
|
|
*/
|
|
UWB_DRP_CONFLICT_ACT3,
|
|
};
|
|
|
|
|
|
static void uwb_rc_set_drp_cmd_done(struct uwb_rc *rc, void *arg,
|
|
struct uwb_rceb *reply, ssize_t reply_size)
|
|
{
|
|
struct uwb_rc_evt_set_drp_ie *r = (struct uwb_rc_evt_set_drp_ie *)reply;
|
|
|
|
if (r != NULL) {
|
|
if (r->bResultCode != UWB_RC_RES_SUCCESS)
|
|
dev_err(&rc->uwb_dev.dev, "SET-DRP-IE failed: %s (%d)\n",
|
|
uwb_rc_strerror(r->bResultCode), r->bResultCode);
|
|
} else
|
|
dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: timeout\n");
|
|
|
|
spin_lock_bh(&rc->rsvs_lock);
|
|
if (rc->set_drp_ie_pending > 1) {
|
|
rc->set_drp_ie_pending = 0;
|
|
uwb_rsv_queue_update(rc);
|
|
} else {
|
|
rc->set_drp_ie_pending = 0;
|
|
}
|
|
spin_unlock_bh(&rc->rsvs_lock);
|
|
}
|
|
|
|
/**
|
|
* Construct and send the SET DRP IE
|
|
*
|
|
* @rc: UWB Host controller
|
|
* @returns: >= 0 number of bytes still available in the beacon
|
|
* < 0 errno code on error.
|
|
*
|
|
* See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
|
|
* device to include in its beacon at the same time. We thus have to
|
|
* traverse all reservations and include the DRP IEs of all PENDING
|
|
* and NEGOTIATED reservations in a SET DRP command for transmission.
|
|
*
|
|
* A DRP Availability IE is appended.
|
|
*
|
|
* rc->rsvs_mutex is held
|
|
*
|
|
* FIXME We currently ignore the returned value indicating the remaining space
|
|
* in beacon. This could be used to deny reservation requests earlier if
|
|
* determined that they would cause the beacon space to be exceeded.
|
|
*/
|
|
int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
|
|
{
|
|
int result;
|
|
struct uwb_rc_cmd_set_drp_ie *cmd;
|
|
struct uwb_rsv *rsv;
|
|
struct uwb_rsv_move *mv;
|
|
int num_bytes = 0;
|
|
u8 *IEDataptr;
|
|
|
|
result = -ENOMEM;
|
|
/* First traverse all reservations to determine memory needed. */
|
|
list_for_each_entry(rsv, &rc->reservations, rc_node) {
|
|
if (rsv->drp_ie != NULL) {
|
|
num_bytes += rsv->drp_ie->hdr.length + 2;
|
|
if (uwb_rsv_has_two_drp_ies(rsv) &&
|
|
(rsv->mv.companion_drp_ie != NULL)) {
|
|
mv = &rsv->mv;
|
|
num_bytes += mv->companion_drp_ie->hdr.length + 2;
|
|
}
|
|
}
|
|
}
|
|
num_bytes += sizeof(rc->drp_avail.ie);
|
|
cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
|
|
if (cmd == NULL)
|
|
goto error;
|
|
cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
|
|
cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
|
|
cmd->wIELength = num_bytes;
|
|
IEDataptr = (u8 *)&cmd->IEData[0];
|
|
|
|
/* FIXME: DRV avail IE is not always needed */
|
|
/* put DRP avail IE first */
|
|
memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));
|
|
IEDataptr += sizeof(struct uwb_ie_drp_avail);
|
|
|
|
/* Next traverse all reservations to place IEs in allocated memory. */
|
|
list_for_each_entry(rsv, &rc->reservations, rc_node) {
|
|
if (rsv->drp_ie != NULL) {
|
|
memcpy(IEDataptr, rsv->drp_ie,
|
|
rsv->drp_ie->hdr.length + 2);
|
|
IEDataptr += rsv->drp_ie->hdr.length + 2;
|
|
|
|
if (uwb_rsv_has_two_drp_ies(rsv) &&
|
|
(rsv->mv.companion_drp_ie != NULL)) {
|
|
mv = &rsv->mv;
|
|
memcpy(IEDataptr, mv->companion_drp_ie,
|
|
mv->companion_drp_ie->hdr.length + 2);
|
|
IEDataptr += mv->companion_drp_ie->hdr.length + 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
result = uwb_rc_cmd_async(rc, "SET-DRP-IE", &cmd->rccb, sizeof(*cmd) + num_bytes,
|
|
UWB_RC_CET_GENERAL, UWB_RC_CMD_SET_DRP_IE,
|
|
uwb_rc_set_drp_cmd_done, NULL);
|
|
|
|
rc->set_drp_ie_pending = 1;
|
|
|
|
kfree(cmd);
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Evaluate the action to perform using conflict resolution rules
|
|
*
|
|
* Return a uwb_drp_conflict_action.
|
|
*/
|
|
static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beacon_slot,
|
|
struct uwb_rsv *rsv, int our_status)
|
|
{
|
|
int our_tie_breaker = rsv->tiebreaker;
|
|
int our_type = rsv->type;
|
|
int our_beacon_slot = rsv->rc->uwb_dev.beacon_slot;
|
|
|
|
int ext_tie_breaker = uwb_ie_drp_tiebreaker(ext_drp_ie);
|
|
int ext_status = uwb_ie_drp_status(ext_drp_ie);
|
|
int ext_type = uwb_ie_drp_type(ext_drp_ie);
|
|
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6 */
|
|
if (ext_type == UWB_DRP_TYPE_PCA && our_type == UWB_DRP_TYPE_PCA) {
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-1 */
|
|
if (our_type == UWB_DRP_TYPE_ALIEN_BP) {
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-2 */
|
|
if (ext_type == UWB_DRP_TYPE_ALIEN_BP) {
|
|
/* here we know our_type != UWB_DRP_TYPE_ALIEN_BP */
|
|
return UWB_DRP_CONFLICT_ACT1;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-3 */
|
|
if (our_status == 0 && ext_status == 1) {
|
|
return UWB_DRP_CONFLICT_ACT2;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-4 */
|
|
if (our_status == 1 && ext_status == 0) {
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-5a */
|
|
if (our_tie_breaker == ext_tie_breaker &&
|
|
our_beacon_slot < ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
/* [ECMA-368 2nd Edition] 17.4.6-5b */
|
|
if (our_tie_breaker != ext_tie_breaker &&
|
|
our_beacon_slot > ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
if (our_status == 0) {
|
|
if (our_tie_breaker == ext_tie_breaker) {
|
|
/* [ECMA-368 2nd Edition] 17.4.6-6a */
|
|
if (our_beacon_slot > ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_ACT2;
|
|
}
|
|
} else {
|
|
/* [ECMA-368 2nd Edition] 17.4.6-6b */
|
|
if (our_beacon_slot < ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_ACT2;
|
|
}
|
|
}
|
|
} else {
|
|
if (our_tie_breaker == ext_tie_breaker) {
|
|
/* [ECMA-368 2nd Edition] 17.4.6-7a */
|
|
if (our_beacon_slot > ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_ACT3;
|
|
}
|
|
} else {
|
|
/* [ECMA-368 2nd Edition] 17.4.6-7b */
|
|
if (our_beacon_slot < ext_beacon_slot) {
|
|
return UWB_DRP_CONFLICT_ACT3;
|
|
}
|
|
}
|
|
}
|
|
return UWB_DRP_CONFLICT_MANTAIN;
|
|
}
|
|
|
|
static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
|
|
int ext_beacon_slot,
|
|
struct uwb_rsv *rsv,
|
|
struct uwb_mas_bm *conflicting_mas)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
struct uwb_rsv_move *mv = &rsv->mv;
|
|
struct uwb_drp_backoff_win *bow = &rc->bow;
|
|
int action;
|
|
|
|
action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, uwb_rsv_status(rsv));
|
|
|
|
if (uwb_rsv_is_owner(rsv)) {
|
|
switch(action) {
|
|
case UWB_DRP_CONFLICT_ACT2:
|
|
/* try move */
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_TO_BE_MOVED);
|
|
if (bow->can_reserve_extra_mases == false)
|
|
uwb_rsv_backoff_win_increment(rc);
|
|
|
|
break;
|
|
case UWB_DRP_CONFLICT_ACT3:
|
|
uwb_rsv_backoff_win_increment(rc);
|
|
/* drop some mases with reason modified */
|
|
/* put in the companion the mases to be dropped */
|
|
bitmap_and(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
|
|
default:
|
|
break;
|
|
}
|
|
} else {
|
|
switch(action) {
|
|
case UWB_DRP_CONFLICT_ACT2:
|
|
case UWB_DRP_CONFLICT_ACT3:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_slot,
|
|
struct uwb_rsv *rsv, bool companion_only,
|
|
struct uwb_mas_bm *conflicting_mas)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
struct uwb_drp_backoff_win *bow = &rc->bow;
|
|
struct uwb_rsv_move *mv = &rsv->mv;
|
|
int action;
|
|
|
|
if (companion_only) {
|
|
/* status of companion is 0 at this point */
|
|
action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, 0);
|
|
if (uwb_rsv_is_owner(rsv)) {
|
|
switch(action) {
|
|
case UWB_DRP_CONFLICT_ACT2:
|
|
case UWB_DRP_CONFLICT_ACT3:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
|
|
rsv->needs_release_companion_mas = false;
|
|
if (bow->can_reserve_extra_mases == false)
|
|
uwb_rsv_backoff_win_increment(rc);
|
|
uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
|
|
}
|
|
} else { /* rsv is target */
|
|
switch(action) {
|
|
case UWB_DRP_CONFLICT_ACT2:
|
|
case UWB_DRP_CONFLICT_ACT3:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_CONFLICT);
|
|
/* send_drp_avail_ie = true; */
|
|
}
|
|
}
|
|
} else { /* also base part of the reservation is conflicting */
|
|
if (uwb_rsv_is_owner(rsv)) {
|
|
uwb_rsv_backoff_win_increment(rc);
|
|
/* remove companion part */
|
|
uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
|
|
|
|
/* drop some mases with reason modified */
|
|
|
|
/* put in the companion the mases to be dropped */
|
|
bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
|
|
} else { /* it is a target rsv */
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
|
|
/* send_drp_avail_ie = true; */
|
|
}
|
|
}
|
|
}
|
|
|
|
static void uwb_drp_handle_conflict_rsv(struct uwb_rc *rc, struct uwb_rsv *rsv,
|
|
struct uwb_rc_evt_drp *drp_evt,
|
|
struct uwb_ie_drp *drp_ie,
|
|
struct uwb_mas_bm *conflicting_mas)
|
|
{
|
|
struct uwb_rsv_move *mv;
|
|
|
|
/* check if the conflicting reservation has two drp_ies */
|
|
if (uwb_rsv_has_two_drp_ies(rsv)) {
|
|
mv = &rsv->mv;
|
|
if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
|
|
handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
|
|
rsv, false, conflicting_mas);
|
|
} else {
|
|
if (bitmap_intersects(mv->companion_mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
|
|
handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
|
|
rsv, true, conflicting_mas);
|
|
}
|
|
}
|
|
} else if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
|
|
handle_conflict_normal(drp_ie, drp_evt->beacon_slot_number, rsv, conflicting_mas);
|
|
}
|
|
}
|
|
|
|
static void uwb_drp_handle_all_conflict_rsv(struct uwb_rc *rc,
|
|
struct uwb_rc_evt_drp *drp_evt,
|
|
struct uwb_ie_drp *drp_ie,
|
|
struct uwb_mas_bm *conflicting_mas)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
|
|
list_for_each_entry(rsv, &rc->reservations, rc_node) {
|
|
uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, conflicting_mas);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Based on the DRP IE, transition a target reservation to a new
|
|
* state.
|
|
*/
|
|
static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
|
|
struct uwb_ie_drp *drp_ie, struct uwb_rc_evt_drp *drp_evt)
|
|
{
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
struct uwb_rsv_move *mv = &rsv->mv;
|
|
int status;
|
|
enum uwb_drp_reason reason_code;
|
|
struct uwb_mas_bm mas;
|
|
|
|
status = uwb_ie_drp_status(drp_ie);
|
|
reason_code = uwb_ie_drp_reason_code(drp_ie);
|
|
uwb_drp_ie_to_bm(&mas, drp_ie);
|
|
|
|
switch (reason_code) {
|
|
case UWB_DRP_REASON_ACCEPTED:
|
|
|
|
if (rsv->state == UWB_RSV_STATE_T_CONFLICT) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
|
|
break;
|
|
}
|
|
|
|
if (rsv->state == UWB_RSV_STATE_T_EXPANDING_ACCEPTED) {
|
|
/* drp_ie is companion */
|
|
if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS))
|
|
/* stroke companion */
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
|
|
} else {
|
|
if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
|
|
if (uwb_drp_avail_reserve_pending(rc, &mas) == -EBUSY) {
|
|
/* FIXME: there is a conflict, find
|
|
* the conflicting reservations and
|
|
* take a sensible action. Consider
|
|
* that in drp_ie there is the
|
|
* "neighbour" */
|
|
uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
|
|
} else {
|
|
/* accept the extra reservation */
|
|
bitmap_copy(mv->companion_mas.bm, mas.bm, UWB_NUM_MAS);
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
|
|
}
|
|
} else {
|
|
if (status) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case UWB_DRP_REASON_MODIFIED:
|
|
/* check to see if we have already modified the reservation */
|
|
if (bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
|
|
break;
|
|
}
|
|
|
|
/* find if the owner wants to expand or reduce */
|
|
if (bitmap_subset(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
|
|
/* owner is reducing */
|
|
bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mas.bm, UWB_NUM_MAS);
|
|
uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
|
|
}
|
|
|
|
bitmap_copy(rsv->mas.bm, mas.bm, UWB_NUM_MAS);
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_RESIZED);
|
|
break;
|
|
default:
|
|
dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
|
|
reason_code, status);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Based on the DRP IE, transition an owner reservation to a new
|
|
* state.
|
|
*/
|
|
static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
|
|
struct uwb_dev *src, struct uwb_ie_drp *drp_ie,
|
|
struct uwb_rc_evt_drp *drp_evt)
|
|
{
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
struct uwb_rsv_move *mv = &rsv->mv;
|
|
int status;
|
|
enum uwb_drp_reason reason_code;
|
|
struct uwb_mas_bm mas;
|
|
|
|
status = uwb_ie_drp_status(drp_ie);
|
|
reason_code = uwb_ie_drp_reason_code(drp_ie);
|
|
uwb_drp_ie_to_bm(&mas, drp_ie);
|
|
|
|
if (status) {
|
|
switch (reason_code) {
|
|
case UWB_DRP_REASON_ACCEPTED:
|
|
switch (rsv->state) {
|
|
case UWB_RSV_STATE_O_PENDING:
|
|
case UWB_RSV_STATE_O_INITIATED:
|
|
case UWB_RSV_STATE_O_ESTABLISHED:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
|
|
break;
|
|
case UWB_RSV_STATE_O_MODIFIED:
|
|
if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
|
|
} else {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
|
|
}
|
|
break;
|
|
|
|
case UWB_RSV_STATE_O_MOVE_REDUCING: /* shouldn' t be a problem */
|
|
if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
|
|
} else {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
|
|
}
|
|
break;
|
|
case UWB_RSV_STATE_O_MOVE_EXPANDING:
|
|
if (bitmap_equal(mas.bm, mv->companion_mas.bm, UWB_NUM_MAS)) {
|
|
/* Companion reservation accepted */
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
|
|
} else {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
|
|
}
|
|
break;
|
|
case UWB_RSV_STATE_O_MOVE_COMBINING:
|
|
if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS))
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
|
|
else
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
|
|
reason_code, status);
|
|
}
|
|
} else {
|
|
switch (reason_code) {
|
|
case UWB_DRP_REASON_PENDING:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
|
|
break;
|
|
case UWB_DRP_REASON_DENIED:
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
|
|
break;
|
|
case UWB_DRP_REASON_CONFLICT:
|
|
/* resolve the conflict */
|
|
bitmap_complement(mas.bm, src->last_availability_bm,
|
|
UWB_NUM_MAS);
|
|
uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, &mas);
|
|
break;
|
|
default:
|
|
dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
|
|
reason_code, status);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void uwb_cnflt_alien_stroke_timer(struct uwb_cnflt_alien *cnflt)
|
|
{
|
|
unsigned timeout_us = UWB_MAX_LOST_BEACONS * UWB_SUPERFRAME_LENGTH_US;
|
|
mod_timer(&cnflt->timer, jiffies + usecs_to_jiffies(timeout_us));
|
|
}
|
|
|
|
static void uwb_cnflt_update_work(struct work_struct *work)
|
|
{
|
|
struct uwb_cnflt_alien *cnflt = container_of(work,
|
|
struct uwb_cnflt_alien,
|
|
cnflt_update_work);
|
|
struct uwb_cnflt_alien *c;
|
|
struct uwb_rc *rc = cnflt->rc;
|
|
|
|
unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
|
|
list_del(&cnflt->rc_node);
|
|
|
|
/* update rc global conflicting alien bitmap */
|
|
bitmap_zero(rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
|
|
|
|
list_for_each_entry(c, &rc->cnflt_alien_list, rc_node) {
|
|
bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, c->mas.bm, UWB_NUM_MAS);
|
|
}
|
|
|
|
queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
|
|
|
|
kfree(cnflt);
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
}
|
|
|
|
static void uwb_cnflt_timer(unsigned long arg)
|
|
{
|
|
struct uwb_cnflt_alien *cnflt = (struct uwb_cnflt_alien *)arg;
|
|
|
|
queue_work(cnflt->rc->rsv_workq, &cnflt->cnflt_update_work);
|
|
}
|
|
|
|
/*
|
|
* We have received an DRP_IE of type Alien BP and we need to make
|
|
* sure we do not transmit in conflicting MASs.
|
|
*/
|
|
static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
struct uwb_mas_bm mas;
|
|
struct uwb_cnflt_alien *cnflt;
|
|
char buf[72];
|
|
unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
|
|
|
|
uwb_drp_ie_to_bm(&mas, drp_ie);
|
|
bitmap_scnprintf(buf, sizeof(buf), mas.bm, UWB_NUM_MAS);
|
|
|
|
list_for_each_entry(cnflt, &rc->cnflt_alien_list, rc_node) {
|
|
if (bitmap_equal(cnflt->mas.bm, mas.bm, UWB_NUM_MAS)) {
|
|
/* Existing alien BP reservation conflicting
|
|
* bitmap, just reset the timer */
|
|
uwb_cnflt_alien_stroke_timer(cnflt);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/* New alien BP reservation conflicting bitmap */
|
|
|
|
/* alloc and initialize new uwb_cnflt_alien */
|
|
cnflt = kzalloc(sizeof(struct uwb_cnflt_alien), GFP_KERNEL);
|
|
if (!cnflt)
|
|
dev_err(dev, "failed to alloc uwb_cnflt_alien struct\n");
|
|
INIT_LIST_HEAD(&cnflt->rc_node);
|
|
init_timer(&cnflt->timer);
|
|
cnflt->timer.function = uwb_cnflt_timer;
|
|
cnflt->timer.data = (unsigned long)cnflt;
|
|
|
|
cnflt->rc = rc;
|
|
INIT_WORK(&cnflt->cnflt_update_work, uwb_cnflt_update_work);
|
|
|
|
bitmap_copy(cnflt->mas.bm, mas.bm, UWB_NUM_MAS);
|
|
|
|
list_add_tail(&cnflt->rc_node, &rc->cnflt_alien_list);
|
|
|
|
/* update rc global conflicting alien bitmap */
|
|
bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, mas.bm, UWB_NUM_MAS);
|
|
|
|
queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
|
|
|
|
/* start the timer */
|
|
uwb_cnflt_alien_stroke_timer(cnflt);
|
|
}
|
|
|
|
static void uwb_drp_process_not_involved(struct uwb_rc *rc,
|
|
struct uwb_rc_evt_drp *drp_evt,
|
|
struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct uwb_mas_bm mas;
|
|
|
|
uwb_drp_ie_to_bm(&mas, drp_ie);
|
|
uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
|
|
}
|
|
|
|
static void uwb_drp_process_involved(struct uwb_rc *rc, struct uwb_dev *src,
|
|
struct uwb_rc_evt_drp *drp_evt,
|
|
struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
|
|
rsv = uwb_rsv_find(rc, src, drp_ie);
|
|
if (!rsv) {
|
|
/*
|
|
* No reservation? It's either for a recently
|
|
* terminated reservation; or the DRP IE couldn't be
|
|
* processed (e.g., an invalid IE or out of memory).
|
|
*/
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Do nothing with DRP IEs for reservations that have been
|
|
* terminated.
|
|
*/
|
|
if (rsv->state == UWB_RSV_STATE_NONE) {
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
|
|
return;
|
|
}
|
|
|
|
if (uwb_ie_drp_owner(drp_ie))
|
|
uwb_drp_process_target(rc, rsv, drp_ie, drp_evt);
|
|
else
|
|
uwb_drp_process_owner(rc, rsv, src, drp_ie, drp_evt);
|
|
|
|
}
|
|
|
|
|
|
static bool uwb_drp_involves_us(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
|
|
{
|
|
return uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, &drp_ie->dev_addr) == 0;
|
|
}
|
|
|
|
/*
|
|
* Process a received DRP IE.
|
|
*/
|
|
static void uwb_drp_process(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
|
|
struct uwb_dev *src, struct uwb_ie_drp *drp_ie)
|
|
{
|
|
if (uwb_ie_drp_type(drp_ie) == UWB_DRP_TYPE_ALIEN_BP)
|
|
uwb_drp_handle_alien_drp(rc, drp_ie);
|
|
else if (uwb_drp_involves_us(rc, drp_ie))
|
|
uwb_drp_process_involved(rc, src, drp_evt, drp_ie);
|
|
else
|
|
uwb_drp_process_not_involved(rc, drp_evt, drp_ie);
|
|
}
|
|
|
|
/*
|
|
* Process a received DRP Availability IE
|
|
*/
|
|
static void uwb_drp_availability_process(struct uwb_rc *rc, struct uwb_dev *src,
|
|
struct uwb_ie_drp_avail *drp_availability_ie)
|
|
{
|
|
bitmap_copy(src->last_availability_bm,
|
|
drp_availability_ie->bmp, UWB_NUM_MAS);
|
|
}
|
|
|
|
/*
|
|
* Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
|
|
* from a device.
|
|
*/
|
|
static
|
|
void uwb_drp_process_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
|
|
size_t ielen, struct uwb_dev *src_dev)
|
|
{
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
struct uwb_ie_hdr *ie_hdr;
|
|
void *ptr;
|
|
|
|
ptr = drp_evt->ie_data;
|
|
for (;;) {
|
|
ie_hdr = uwb_ie_next(&ptr, &ielen);
|
|
if (!ie_hdr)
|
|
break;
|
|
|
|
switch (ie_hdr->element_id) {
|
|
case UWB_IE_DRP_AVAILABILITY:
|
|
uwb_drp_availability_process(rc, src_dev, (struct uwb_ie_drp_avail *)ie_hdr);
|
|
break;
|
|
case UWB_IE_DRP:
|
|
uwb_drp_process(rc, drp_evt, src_dev, (struct uwb_ie_drp *)ie_hdr);
|
|
break;
|
|
default:
|
|
dev_warn(dev, "unexpected IE in DRP notification\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (ielen > 0)
|
|
dev_warn(dev, "%d octets remaining in DRP notification\n",
|
|
(int)ielen);
|
|
}
|
|
|
|
/**
|
|
* uwbd_evt_handle_rc_drp - handle a DRP_IE event
|
|
* @evt: the DRP_IE event from the radio controller
|
|
*
|
|
* This processes DRP notifications from the radio controller, either
|
|
* initiating a new reservation or transitioning an existing
|
|
* reservation into a different state.
|
|
*
|
|
* DRP notifications can occur for three different reasons:
|
|
*
|
|
* - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
|
|
* the target or source have been received.
|
|
*
|
|
* These DRP IEs could be new or for an existing reservation.
|
|
*
|
|
* If the DRP IE for an existing reservation ceases to be to
|
|
* received for at least mMaxLostBeacons, the reservation should be
|
|
* considered to be terminated. Note that the TERMINATE reason (see
|
|
* below) may not always be signalled (e.g., the remote device has
|
|
* two or more reservations established with the RC).
|
|
*
|
|
* - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
|
|
* group conflict with the RC's reservations.
|
|
*
|
|
* - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
|
|
* from a device (i.e., it's terminated all reservations).
|
|
*
|
|
* Only the software state of the reservations is changed; the setting
|
|
* of the radio controller's DRP IEs is done after all the events in
|
|
* an event buffer are processed. This saves waiting multiple times
|
|
* for the SET_DRP_IE command to complete.
|
|
*/
|
|
int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
|
|
{
|
|
struct device *dev = &evt->rc->uwb_dev.dev;
|
|
struct uwb_rc *rc = evt->rc;
|
|
struct uwb_rc_evt_drp *drp_evt;
|
|
size_t ielength, bytes_left;
|
|
struct uwb_dev_addr src_addr;
|
|
struct uwb_dev *src_dev;
|
|
|
|
/* Is there enough data to decode the event (and any IEs in
|
|
its payload)? */
|
|
if (evt->notif.size < sizeof(*drp_evt)) {
|
|
dev_err(dev, "DRP event: Not enough data to decode event "
|
|
"[%zu bytes left, %zu needed]\n",
|
|
evt->notif.size, sizeof(*drp_evt));
|
|
return 0;
|
|
}
|
|
bytes_left = evt->notif.size - sizeof(*drp_evt);
|
|
drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
|
|
ielength = le16_to_cpu(drp_evt->ie_length);
|
|
if (bytes_left != ielength) {
|
|
dev_err(dev, "DRP event: Not enough data in payload [%zu"
|
|
"bytes left, %zu declared in the event]\n",
|
|
bytes_left, ielength);
|
|
return 0;
|
|
}
|
|
|
|
memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
|
|
src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
|
|
if (!src_dev) {
|
|
/*
|
|
* A DRP notification from an unrecognized device.
|
|
*
|
|
* This is probably from a WUSB device that doesn't
|
|
* have an EUI-48 and therefore doesn't show up in the
|
|
* UWB device database. It's safe to simply ignore
|
|
* these.
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
|
|
/* We do not distinguish from the reason */
|
|
uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
|
|
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
|
|
uwb_dev_put(src_dev);
|
|
return 0;
|
|
}
|