![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 503 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Enrico Weigelt <info@metux.net> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190602204653.811534538@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
306 lines
9 KiB
C
306 lines
9 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* UWB DRP IE management.
|
|
*
|
|
* Copyright (C) 2005-2006 Intel Corporation
|
|
* Copyright (C) 2008 Cambridge Silicon Radio Ltd.
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/random.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/uwb.h>
|
|
|
|
#include "uwb-internal.h"
|
|
|
|
|
|
/*
|
|
* Return the reason code for a reservations's DRP IE.
|
|
*/
|
|
static int uwb_rsv_reason_code(struct uwb_rsv *rsv)
|
|
{
|
|
static const int reason_codes[] = {
|
|
[UWB_RSV_STATE_O_INITIATED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_O_PENDING] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_O_MODIFIED] = UWB_DRP_REASON_MODIFIED,
|
|
[UWB_RSV_STATE_O_ESTABLISHED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_O_TO_BE_MOVED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_O_MOVE_COMBINING] = UWB_DRP_REASON_MODIFIED,
|
|
[UWB_RSV_STATE_O_MOVE_REDUCING] = UWB_DRP_REASON_MODIFIED,
|
|
[UWB_RSV_STATE_O_MOVE_EXPANDING] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_CONFLICT] = UWB_DRP_REASON_CONFLICT,
|
|
[UWB_RSV_STATE_T_PENDING] = UWB_DRP_REASON_PENDING,
|
|
[UWB_RSV_STATE_T_DENIED] = UWB_DRP_REASON_DENIED,
|
|
[UWB_RSV_STATE_T_RESIZED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_EXPANDING_CONFLICT] = UWB_DRP_REASON_CONFLICT,
|
|
[UWB_RSV_STATE_T_EXPANDING_PENDING] = UWB_DRP_REASON_PENDING,
|
|
[UWB_RSV_STATE_T_EXPANDING_DENIED] = UWB_DRP_REASON_DENIED,
|
|
};
|
|
|
|
return reason_codes[rsv->state];
|
|
}
|
|
|
|
/*
|
|
* Return the reason code for a reservations's companion DRP IE .
|
|
*/
|
|
static int uwb_rsv_companion_reason_code(struct uwb_rsv *rsv)
|
|
{
|
|
static const int companion_reason_codes[] = {
|
|
[UWB_RSV_STATE_O_MOVE_EXPANDING] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
|
|
[UWB_RSV_STATE_T_EXPANDING_CONFLICT] = UWB_DRP_REASON_CONFLICT,
|
|
[UWB_RSV_STATE_T_EXPANDING_PENDING] = UWB_DRP_REASON_PENDING,
|
|
[UWB_RSV_STATE_T_EXPANDING_DENIED] = UWB_DRP_REASON_DENIED,
|
|
};
|
|
|
|
return companion_reason_codes[rsv->state];
|
|
}
|
|
|
|
/*
|
|
* Return the status bit for a reservations's DRP IE.
|
|
*/
|
|
int uwb_rsv_status(struct uwb_rsv *rsv)
|
|
{
|
|
static const int statuses[] = {
|
|
[UWB_RSV_STATE_O_INITIATED] = 0,
|
|
[UWB_RSV_STATE_O_PENDING] = 0,
|
|
[UWB_RSV_STATE_O_MODIFIED] = 1,
|
|
[UWB_RSV_STATE_O_ESTABLISHED] = 1,
|
|
[UWB_RSV_STATE_O_TO_BE_MOVED] = 0,
|
|
[UWB_RSV_STATE_O_MOVE_COMBINING] = 1,
|
|
[UWB_RSV_STATE_O_MOVE_REDUCING] = 1,
|
|
[UWB_RSV_STATE_O_MOVE_EXPANDING] = 1,
|
|
[UWB_RSV_STATE_T_ACCEPTED] = 1,
|
|
[UWB_RSV_STATE_T_CONFLICT] = 0,
|
|
[UWB_RSV_STATE_T_PENDING] = 0,
|
|
[UWB_RSV_STATE_T_DENIED] = 0,
|
|
[UWB_RSV_STATE_T_RESIZED] = 1,
|
|
[UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = 1,
|
|
[UWB_RSV_STATE_T_EXPANDING_CONFLICT] = 1,
|
|
[UWB_RSV_STATE_T_EXPANDING_PENDING] = 1,
|
|
[UWB_RSV_STATE_T_EXPANDING_DENIED] = 1,
|
|
|
|
};
|
|
|
|
return statuses[rsv->state];
|
|
}
|
|
|
|
/*
|
|
* Return the status bit for a reservations's companion DRP IE .
|
|
*/
|
|
int uwb_rsv_companion_status(struct uwb_rsv *rsv)
|
|
{
|
|
static const int companion_statuses[] = {
|
|
[UWB_RSV_STATE_O_MOVE_EXPANDING] = 0,
|
|
[UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = 1,
|
|
[UWB_RSV_STATE_T_EXPANDING_CONFLICT] = 0,
|
|
[UWB_RSV_STATE_T_EXPANDING_PENDING] = 0,
|
|
[UWB_RSV_STATE_T_EXPANDING_DENIED] = 0,
|
|
};
|
|
|
|
return companion_statuses[rsv->state];
|
|
}
|
|
|
|
/*
|
|
* Allocate a DRP IE.
|
|
*
|
|
* To save having to free/allocate a DRP IE when its MAS changes,
|
|
* enough memory is allocated for the maxiumum number of DRP
|
|
* allocation fields. This gives an overhead per reservation of up to
|
|
* (UWB_NUM_ZONES - 1) * 4 = 60 octets.
|
|
*/
|
|
static struct uwb_ie_drp *uwb_drp_ie_alloc(void)
|
|
{
|
|
struct uwb_ie_drp *drp_ie;
|
|
|
|
drp_ie = kzalloc(struct_size(drp_ie, allocs, UWB_NUM_ZONES),
|
|
GFP_KERNEL);
|
|
if (drp_ie)
|
|
drp_ie->hdr.element_id = UWB_IE_DRP;
|
|
return drp_ie;
|
|
}
|
|
|
|
|
|
/*
|
|
* Fill a DRP IE's allocation fields from a MAS bitmap.
|
|
*/
|
|
static void uwb_drp_ie_from_bm(struct uwb_ie_drp *drp_ie,
|
|
struct uwb_mas_bm *mas)
|
|
{
|
|
int z, i, num_fields = 0, next = 0;
|
|
struct uwb_drp_alloc *zones;
|
|
__le16 current_bmp;
|
|
DECLARE_BITMAP(tmp_bmp, UWB_NUM_MAS);
|
|
DECLARE_BITMAP(tmp_mas_bm, UWB_MAS_PER_ZONE);
|
|
|
|
zones = drp_ie->allocs;
|
|
|
|
bitmap_copy(tmp_bmp, mas->bm, UWB_NUM_MAS);
|
|
|
|
/* Determine unique MAS bitmaps in zones from bitmap. */
|
|
for (z = 0; z < UWB_NUM_ZONES; z++) {
|
|
bitmap_copy(tmp_mas_bm, tmp_bmp, UWB_MAS_PER_ZONE);
|
|
if (bitmap_weight(tmp_mas_bm, UWB_MAS_PER_ZONE) > 0) {
|
|
bool found = false;
|
|
current_bmp = (__le16) *tmp_mas_bm;
|
|
for (i = 0; i < next; i++) {
|
|
if (current_bmp == zones[i].mas_bm) {
|
|
zones[i].zone_bm |= 1 << z;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
num_fields++;
|
|
zones[next].zone_bm = 1 << z;
|
|
zones[next].mas_bm = current_bmp;
|
|
next++;
|
|
}
|
|
}
|
|
bitmap_shift_right(tmp_bmp, tmp_bmp, UWB_MAS_PER_ZONE, UWB_NUM_MAS);
|
|
}
|
|
|
|
/* Store in format ready for transmission (le16). */
|
|
for (i = 0; i < num_fields; i++) {
|
|
drp_ie->allocs[i].zone_bm = cpu_to_le16(zones[i].zone_bm);
|
|
drp_ie->allocs[i].mas_bm = cpu_to_le16(zones[i].mas_bm);
|
|
}
|
|
|
|
drp_ie->hdr.length = sizeof(struct uwb_ie_drp) - sizeof(struct uwb_ie_hdr)
|
|
+ num_fields * sizeof(struct uwb_drp_alloc);
|
|
}
|
|
|
|
/**
|
|
* uwb_drp_ie_update - update a reservation's DRP IE
|
|
* @rsv: the reservation
|
|
*/
|
|
int uwb_drp_ie_update(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_ie_drp *drp_ie;
|
|
struct uwb_rsv_move *mv;
|
|
int unsafe;
|
|
|
|
if (rsv->state == UWB_RSV_STATE_NONE) {
|
|
kfree(rsv->drp_ie);
|
|
rsv->drp_ie = NULL;
|
|
return 0;
|
|
}
|
|
|
|
unsafe = rsv->mas.unsafe ? 1 : 0;
|
|
|
|
if (rsv->drp_ie == NULL) {
|
|
rsv->drp_ie = uwb_drp_ie_alloc();
|
|
if (rsv->drp_ie == NULL)
|
|
return -ENOMEM;
|
|
}
|
|
drp_ie = rsv->drp_ie;
|
|
|
|
uwb_ie_drp_set_unsafe(drp_ie, unsafe);
|
|
uwb_ie_drp_set_tiebreaker(drp_ie, rsv->tiebreaker);
|
|
uwb_ie_drp_set_owner(drp_ie, uwb_rsv_is_owner(rsv));
|
|
uwb_ie_drp_set_status(drp_ie, uwb_rsv_status(rsv));
|
|
uwb_ie_drp_set_reason_code(drp_ie, uwb_rsv_reason_code(rsv));
|
|
uwb_ie_drp_set_stream_index(drp_ie, rsv->stream);
|
|
uwb_ie_drp_set_type(drp_ie, rsv->type);
|
|
|
|
if (uwb_rsv_is_owner(rsv)) {
|
|
switch (rsv->target.type) {
|
|
case UWB_RSV_TARGET_DEV:
|
|
drp_ie->dev_addr = rsv->target.dev->dev_addr;
|
|
break;
|
|
case UWB_RSV_TARGET_DEVADDR:
|
|
drp_ie->dev_addr = rsv->target.devaddr;
|
|
break;
|
|
}
|
|
} else
|
|
drp_ie->dev_addr = rsv->owner->dev_addr;
|
|
|
|
uwb_drp_ie_from_bm(drp_ie, &rsv->mas);
|
|
|
|
if (uwb_rsv_has_two_drp_ies(rsv)) {
|
|
mv = &rsv->mv;
|
|
if (mv->companion_drp_ie == NULL) {
|
|
mv->companion_drp_ie = uwb_drp_ie_alloc();
|
|
if (mv->companion_drp_ie == NULL)
|
|
return -ENOMEM;
|
|
}
|
|
drp_ie = mv->companion_drp_ie;
|
|
|
|
/* keep all the same configuration of the main drp_ie */
|
|
memcpy(drp_ie, rsv->drp_ie, sizeof(struct uwb_ie_drp));
|
|
|
|
|
|
/* FIXME: handle properly the unsafe bit */
|
|
uwb_ie_drp_set_unsafe(drp_ie, 1);
|
|
uwb_ie_drp_set_status(drp_ie, uwb_rsv_companion_status(rsv));
|
|
uwb_ie_drp_set_reason_code(drp_ie, uwb_rsv_companion_reason_code(rsv));
|
|
|
|
uwb_drp_ie_from_bm(drp_ie, &mv->companion_mas);
|
|
}
|
|
|
|
rsv->ie_valid = true;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Set MAS bits from given MAS bitmap in a single zone of large bitmap.
|
|
*
|
|
* We are given a zone id and the MAS bitmap of bits that need to be set in
|
|
* this zone. Note that this zone may already have bits set and this only
|
|
* adds settings - we cannot simply assign the MAS bitmap contents to the
|
|
* zone contents. We iterate over the the bits (MAS) in the zone and set the
|
|
* bits that are set in the given MAS bitmap.
|
|
*/
|
|
static
|
|
void uwb_drp_ie_single_zone_to_bm(struct uwb_mas_bm *bm, u8 zone, u16 mas_bm)
|
|
{
|
|
int mas;
|
|
u16 mas_mask;
|
|
|
|
for (mas = 0; mas < UWB_MAS_PER_ZONE; mas++) {
|
|
mas_mask = 1 << mas;
|
|
if (mas_bm & mas_mask)
|
|
set_bit(zone * UWB_NUM_ZONES + mas, bm->bm);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* uwb_drp_ie_zones_to_bm - convert DRP allocation fields to a bitmap
|
|
* @mas: MAS bitmap that will be populated to correspond to the
|
|
* allocation fields in the DRP IE
|
|
* @drp_ie: the DRP IE that contains the allocation fields.
|
|
*
|
|
* The input format is an array of MAS allocation fields (16 bit Zone
|
|
* bitmap, 16 bit MAS bitmap) as described in [ECMA-368] section
|
|
* 16.8.6. The output is a full 256 bit MAS bitmap.
|
|
*
|
|
* We go over all the allocation fields, for each allocation field we
|
|
* know which zones are impacted. We iterate over all the zones
|
|
* impacted and call a function that will set the correct MAS bits in
|
|
* each zone.
|
|
*/
|
|
void uwb_drp_ie_to_bm(struct uwb_mas_bm *bm, const struct uwb_ie_drp *drp_ie)
|
|
{
|
|
int numallocs = (drp_ie->hdr.length - 4) / 4;
|
|
const struct uwb_drp_alloc *alloc;
|
|
int cnt;
|
|
u16 zone_bm, mas_bm;
|
|
u8 zone;
|
|
u16 zone_mask;
|
|
|
|
bitmap_zero(bm->bm, UWB_NUM_MAS);
|
|
|
|
for (cnt = 0; cnt < numallocs; cnt++) {
|
|
alloc = &drp_ie->allocs[cnt];
|
|
zone_bm = le16_to_cpu(alloc->zone_bm);
|
|
mas_bm = le16_to_cpu(alloc->mas_bm);
|
|
for (zone = 0; zone < UWB_NUM_ZONES; zone++) {
|
|
zone_mask = 1 << zone;
|
|
if (zone_bm & zone_mask)
|
|
uwb_drp_ie_single_zone_to_bm(bm, zone, mas_bm);
|
|
}
|
|
}
|
|
}
|
|
|