mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-07 00:26:41 +07:00
8cc13a0947
DRP and reservation management. Signed-off-by: David Vrabel <david.vrabel@csr.com>
681 lines
17 KiB
C
681 lines
17 KiB
C
/*
|
|
* UWB reservation management.
|
|
*
|
|
* 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/version.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/uwb.h>
|
|
|
|
#include "uwb-internal.h"
|
|
|
|
static void uwb_rsv_timer(unsigned long arg);
|
|
|
|
static const char *rsv_states[] = {
|
|
[UWB_RSV_STATE_NONE] = "none",
|
|
[UWB_RSV_STATE_O_INITIATED] = "initiated",
|
|
[UWB_RSV_STATE_O_PENDING] = "pending",
|
|
[UWB_RSV_STATE_O_MODIFIED] = "modified",
|
|
[UWB_RSV_STATE_O_ESTABLISHED] = "established",
|
|
[UWB_RSV_STATE_T_ACCEPTED] = "accepted",
|
|
[UWB_RSV_STATE_T_DENIED] = "denied",
|
|
[UWB_RSV_STATE_T_PENDING] = "pending",
|
|
};
|
|
|
|
static const char *rsv_types[] = {
|
|
[UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
|
|
[UWB_DRP_TYPE_HARD] = "hard",
|
|
[UWB_DRP_TYPE_SOFT] = "soft",
|
|
[UWB_DRP_TYPE_PRIVATE] = "private",
|
|
[UWB_DRP_TYPE_PCA] = "pca",
|
|
};
|
|
|
|
/**
|
|
* uwb_rsv_state_str - return a string for a reservation state
|
|
* @state: the reservation state.
|
|
*/
|
|
const char *uwb_rsv_state_str(enum uwb_rsv_state state)
|
|
{
|
|
if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
|
|
return "unknown";
|
|
return rsv_states[state];
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
|
|
|
|
/**
|
|
* uwb_rsv_type_str - return a string for a reservation type
|
|
* @type: the reservation type
|
|
*/
|
|
const char *uwb_rsv_type_str(enum uwb_drp_type type)
|
|
{
|
|
if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
|
|
return "invalid";
|
|
return rsv_types[type];
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
|
|
|
|
static void uwb_rsv_dump(struct uwb_rsv *rsv)
|
|
{
|
|
struct device *dev = &rsv->rc->uwb_dev.dev;
|
|
struct uwb_dev_addr devaddr;
|
|
char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
|
|
|
|
uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
|
|
if (rsv->target.type == UWB_RSV_TARGET_DEV)
|
|
devaddr = rsv->target.dev->dev_addr;
|
|
else
|
|
devaddr = rsv->target.devaddr;
|
|
uwb_dev_addr_print(target, sizeof(target), &devaddr);
|
|
|
|
dev_dbg(dev, "rsv %s -> %s: %s\n", owner, target, uwb_rsv_state_str(rsv->state));
|
|
}
|
|
|
|
/*
|
|
* Get a free stream index for a reservation.
|
|
*
|
|
* If the target is a DevAddr (e.g., a WUSB cluster reservation) then
|
|
* the stream is allocated from a pool of per-RC stream indexes,
|
|
* otherwise a unique stream index for the target is selected.
|
|
*/
|
|
static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
unsigned long *streams_bm;
|
|
int stream;
|
|
|
|
switch (rsv->target.type) {
|
|
case UWB_RSV_TARGET_DEV:
|
|
streams_bm = rsv->target.dev->streams;
|
|
break;
|
|
case UWB_RSV_TARGET_DEVADDR:
|
|
streams_bm = rc->uwb_dev.streams;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
|
|
if (stream >= UWB_NUM_STREAMS)
|
|
return -EBUSY;
|
|
|
|
rsv->stream = stream;
|
|
set_bit(stream, streams_bm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
unsigned long *streams_bm;
|
|
|
|
switch (rsv->target.type) {
|
|
case UWB_RSV_TARGET_DEV:
|
|
streams_bm = rsv->target.dev->streams;
|
|
break;
|
|
case UWB_RSV_TARGET_DEVADDR:
|
|
streams_bm = rc->uwb_dev.streams;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
clear_bit(rsv->stream, streams_bm);
|
|
}
|
|
|
|
/*
|
|
* Generate a MAS allocation with a single row component.
|
|
*/
|
|
static void uwb_rsv_gen_alloc_row(struct uwb_mas_bm *mas,
|
|
int first_mas, int mas_per_zone,
|
|
int zs, int ze)
|
|
{
|
|
struct uwb_mas_bm col;
|
|
int z;
|
|
|
|
bitmap_zero(mas->bm, UWB_NUM_MAS);
|
|
bitmap_zero(col.bm, UWB_NUM_MAS);
|
|
bitmap_fill(col.bm, mas_per_zone);
|
|
bitmap_shift_left(col.bm, col.bm, first_mas + zs * UWB_MAS_PER_ZONE, UWB_NUM_MAS);
|
|
|
|
for (z = zs; z <= ze; z++) {
|
|
bitmap_or(mas->bm, mas->bm, col.bm, UWB_NUM_MAS);
|
|
bitmap_shift_left(col.bm, col.bm, UWB_MAS_PER_ZONE, UWB_NUM_MAS);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Allocate some MAS for this reservation based on current local
|
|
* availability, the reservation parameters (max_mas, min_mas,
|
|
* sparsity), and the WiMedia rules for MAS allocations.
|
|
*
|
|
* Returns -EBUSY is insufficient free MAS are available.
|
|
*
|
|
* FIXME: to simplify this, only safe reservations with a single row
|
|
* component in zones 1 to 15 are tried (zone 0 is skipped to avoid
|
|
* problems with the MAS reserved for the BP).
|
|
*
|
|
* [ECMA-368] section B.2.
|
|
*/
|
|
static int uwb_rsv_alloc_mas(struct uwb_rsv *rsv)
|
|
{
|
|
static const int safe_mas_in_row[UWB_NUM_ZONES] = {
|
|
8, 7, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1,
|
|
};
|
|
int n, r;
|
|
struct uwb_mas_bm mas;
|
|
bool found = false;
|
|
|
|
/*
|
|
* Search all valid safe allocations until either: too few MAS
|
|
* are available; or the smallest allocation with sufficient
|
|
* MAS is found.
|
|
*
|
|
* The top of the zones are preferred, so space for larger
|
|
* allocations is available in the bottom of the zone (e.g., a
|
|
* 15 MAS allocation should start in row 14 leaving space for
|
|
* a 120 MAS allocation at row 0).
|
|
*/
|
|
for (n = safe_mas_in_row[0]; n >= 1; n--) {
|
|
int num_mas;
|
|
|
|
num_mas = n * (UWB_NUM_ZONES - 1);
|
|
if (num_mas < rsv->min_mas)
|
|
break;
|
|
if (found && num_mas < rsv->max_mas)
|
|
break;
|
|
|
|
for (r = UWB_MAS_PER_ZONE-1; r >= 0; r--) {
|
|
if (safe_mas_in_row[r] < n)
|
|
continue;
|
|
uwb_rsv_gen_alloc_row(&mas, r, n, 1, UWB_NUM_ZONES);
|
|
if (uwb_drp_avail_reserve_pending(rsv->rc, &mas) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
return -EBUSY;
|
|
|
|
bitmap_copy(rsv->mas.bm, mas.bm, UWB_NUM_MAS);
|
|
return 0;
|
|
}
|
|
|
|
static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
|
|
{
|
|
int sframes = UWB_MAX_LOST_BEACONS;
|
|
|
|
/*
|
|
* Multicast reservations can become established within 1
|
|
* super frame and should not be terminated if no response is
|
|
* received.
|
|
*/
|
|
if (rsv->is_multicast) {
|
|
if (rsv->state == UWB_RSV_STATE_O_INITIATED)
|
|
sframes = 1;
|
|
if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
|
|
sframes = 0;
|
|
}
|
|
|
|
rsv->expired = false;
|
|
if (sframes > 0) {
|
|
/*
|
|
* Add an additional 2 superframes to account for the
|
|
* time to send the SET DRP IE command.
|
|
*/
|
|
unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
|
|
mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
|
|
} else
|
|
del_timer(&rsv->timer);
|
|
}
|
|
|
|
/*
|
|
* Update a reservations state, and schedule an update of the
|
|
* transmitted DRP IEs.
|
|
*/
|
|
static void uwb_rsv_state_update(struct uwb_rsv *rsv,
|
|
enum uwb_rsv_state new_state)
|
|
{
|
|
rsv->state = new_state;
|
|
rsv->ie_valid = false;
|
|
|
|
uwb_rsv_dump(rsv);
|
|
|
|
uwb_rsv_stroke_timer(rsv);
|
|
uwb_rsv_sched_update(rsv->rc);
|
|
}
|
|
|
|
static void uwb_rsv_callback(struct uwb_rsv *rsv)
|
|
{
|
|
if (rsv->callback)
|
|
rsv->callback(rsv);
|
|
}
|
|
|
|
void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
|
|
{
|
|
if (rsv->state == new_state) {
|
|
switch (rsv->state) {
|
|
case UWB_RSV_STATE_O_ESTABLISHED:
|
|
case UWB_RSV_STATE_T_ACCEPTED:
|
|
case UWB_RSV_STATE_NONE:
|
|
uwb_rsv_stroke_timer(rsv);
|
|
break;
|
|
default:
|
|
/* Expecting a state transition so leave timer
|
|
as-is. */
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch (new_state) {
|
|
case UWB_RSV_STATE_NONE:
|
|
uwb_drp_avail_release(rsv->rc, &rsv->mas);
|
|
uwb_rsv_put_stream(rsv);
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
|
|
uwb_rsv_callback(rsv);
|
|
break;
|
|
case UWB_RSV_STATE_O_INITIATED:
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
|
|
break;
|
|
case UWB_RSV_STATE_O_PENDING:
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
|
|
break;
|
|
case UWB_RSV_STATE_O_ESTABLISHED:
|
|
uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
|
|
uwb_rsv_callback(rsv);
|
|
break;
|
|
case UWB_RSV_STATE_T_ACCEPTED:
|
|
uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
|
|
uwb_rsv_callback(rsv);
|
|
break;
|
|
case UWB_RSV_STATE_T_DENIED:
|
|
uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
|
|
break;
|
|
default:
|
|
dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
|
|
uwb_rsv_state_str(new_state), new_state);
|
|
}
|
|
}
|
|
|
|
static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
|
|
rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
|
|
if (!rsv)
|
|
return NULL;
|
|
|
|
INIT_LIST_HEAD(&rsv->rc_node);
|
|
INIT_LIST_HEAD(&rsv->pal_node);
|
|
init_timer(&rsv->timer);
|
|
rsv->timer.function = uwb_rsv_timer;
|
|
rsv->timer.data = (unsigned long)rsv;
|
|
|
|
rsv->rc = rc;
|
|
|
|
return rsv;
|
|
}
|
|
|
|
static void uwb_rsv_free(struct uwb_rsv *rsv)
|
|
{
|
|
uwb_dev_put(rsv->owner);
|
|
if (rsv->target.type == UWB_RSV_TARGET_DEV)
|
|
uwb_dev_put(rsv->target.dev);
|
|
kfree(rsv);
|
|
}
|
|
|
|
/**
|
|
* uwb_rsv_create - allocate and initialize a UWB reservation structure
|
|
* @rc: the radio controller
|
|
* @cb: callback to use when the reservation completes or terminates
|
|
* @pal_priv: data private to the PAL to be passed in the callback
|
|
*
|
|
* The callback is called when the state of the reservation changes from:
|
|
*
|
|
* - pending to accepted
|
|
* - pending to denined
|
|
* - accepted to terminated
|
|
* - pending to terminated
|
|
*/
|
|
struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
|
|
rsv = uwb_rsv_alloc(rc);
|
|
if (!rsv)
|
|
return NULL;
|
|
|
|
rsv->callback = cb;
|
|
rsv->pal_priv = pal_priv;
|
|
|
|
return rsv;
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_create);
|
|
|
|
void uwb_rsv_remove(struct uwb_rsv *rsv)
|
|
{
|
|
if (rsv->state != UWB_RSV_STATE_NONE)
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
|
|
del_timer_sync(&rsv->timer);
|
|
list_del(&rsv->rc_node);
|
|
uwb_rsv_free(rsv);
|
|
}
|
|
|
|
/**
|
|
* uwb_rsv_destroy - free a UWB reservation structure
|
|
* @rsv: the reservation to free
|
|
*
|
|
* The reservation will be terminated if it is pending or established.
|
|
*/
|
|
void uwb_rsv_destroy(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
uwb_rsv_remove(rsv);
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
|
|
|
|
/**
|
|
* usb_rsv_establish - start a reservation establishment
|
|
* @rsv: the reservation
|
|
*
|
|
* The PAL should fill in @rsv's owner, target, type, max_mas,
|
|
* min_mas, sparsity and is_multicast fields. If the target is a
|
|
* uwb_dev it must be referenced.
|
|
*
|
|
* The reservation's callback will be called when the reservation is
|
|
* accepted, denied or times out.
|
|
*/
|
|
int uwb_rsv_establish(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
int ret;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
|
|
ret = uwb_rsv_get_stream(rsv);
|
|
if (ret)
|
|
goto out;
|
|
|
|
ret = uwb_rsv_alloc_mas(rsv);
|
|
if (ret) {
|
|
uwb_rsv_put_stream(rsv);
|
|
goto out;
|
|
}
|
|
|
|
list_add_tail(&rsv->rc_node, &rc->reservations);
|
|
rsv->owner = &rc->uwb_dev;
|
|
uwb_dev_get(rsv->owner);
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
|
|
out:
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_establish);
|
|
|
|
/**
|
|
* uwb_rsv_modify - modify an already established reservation
|
|
* @rsv: the reservation to modify
|
|
* @max_mas: new maximum MAS to reserve
|
|
* @min_mas: new minimum MAS to reserve
|
|
* @sparsity: new sparsity to use
|
|
*
|
|
* FIXME: implement this once there are PALs that use it.
|
|
*/
|
|
int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int sparsity)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_modify);
|
|
|
|
/**
|
|
* uwb_rsv_terminate - terminate an established reservation
|
|
* @rsv: the reservation to terminate
|
|
*
|
|
* A reservation is terminated by removing the DRP IE from the beacon,
|
|
* the other end will consider the reservation to be terminated when
|
|
* it does not see the DRP IE for at least mMaxLostBeacons.
|
|
*
|
|
* If applicable, the reference to the target uwb_dev will be released.
|
|
*/
|
|
void uwb_rsv_terminate(struct uwb_rsv *rsv)
|
|
{
|
|
struct uwb_rc *rc = rsv->rc;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
|
|
uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
|
|
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
|
|
|
|
/**
|
|
* uwb_rsv_accept - accept a new reservation from a peer
|
|
* @rsv: the reservation
|
|
* @cb: call back for reservation changes
|
|
* @pal_priv: data to be passed in the above call back
|
|
*
|
|
* Reservation requests from peers are denied unless a PAL accepts it
|
|
* by calling this function.
|
|
*/
|
|
void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
|
|
{
|
|
rsv->callback = cb;
|
|
rsv->pal_priv = pal_priv;
|
|
rsv->state = UWB_RSV_STATE_T_ACCEPTED;
|
|
}
|
|
EXPORT_SYMBOL_GPL(uwb_rsv_accept);
|
|
|
|
/*
|
|
* Is a received DRP IE for this reservation?
|
|
*/
|
|
static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
|
|
struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct uwb_dev_addr *rsv_src;
|
|
int stream;
|
|
|
|
stream = uwb_ie_drp_stream_index(drp_ie);
|
|
|
|
if (rsv->stream != stream)
|
|
return false;
|
|
|
|
switch (rsv->target.type) {
|
|
case UWB_RSV_TARGET_DEVADDR:
|
|
return rsv->stream == stream;
|
|
case UWB_RSV_TARGET_DEV:
|
|
if (uwb_ie_drp_owner(drp_ie))
|
|
rsv_src = &rsv->owner->dev_addr;
|
|
else
|
|
rsv_src = &rsv->target.dev->dev_addr;
|
|
return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
|
|
struct uwb_dev *src,
|
|
struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
struct uwb_pal *pal;
|
|
enum uwb_rsv_state state;
|
|
|
|
rsv = uwb_rsv_alloc(rc);
|
|
if (!rsv)
|
|
return NULL;
|
|
|
|
rsv->rc = rc;
|
|
rsv->owner = src;
|
|
uwb_dev_get(rsv->owner);
|
|
rsv->target.type = UWB_RSV_TARGET_DEV;
|
|
rsv->target.dev = &rc->uwb_dev;
|
|
rsv->type = uwb_ie_drp_type(drp_ie);
|
|
rsv->stream = uwb_ie_drp_stream_index(drp_ie);
|
|
set_bit(rsv->stream, rsv->owner->streams);
|
|
uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
|
|
|
|
/*
|
|
* See if any PALs are interested in this reservation. If not,
|
|
* deny the request.
|
|
*/
|
|
rsv->state = UWB_RSV_STATE_T_DENIED;
|
|
spin_lock(&rc->pal_lock);
|
|
list_for_each_entry(pal, &rc->pals, node) {
|
|
if (pal->new_rsv)
|
|
pal->new_rsv(rsv);
|
|
if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
|
|
break;
|
|
}
|
|
spin_unlock(&rc->pal_lock);
|
|
|
|
list_add_tail(&rsv->rc_node, &rc->reservations);
|
|
state = rsv->state;
|
|
rsv->state = UWB_RSV_STATE_NONE;
|
|
uwb_rsv_set_state(rsv, state);
|
|
|
|
return rsv;
|
|
}
|
|
|
|
/**
|
|
* uwb_rsv_find - find a reservation for a received DRP IE.
|
|
* @rc: the radio controller
|
|
* @src: source of the DRP IE
|
|
* @drp_ie: the DRP IE
|
|
*
|
|
* If the reservation cannot be found and the DRP IE is from a peer
|
|
* attempting to establish a new reservation, create a new reservation
|
|
* and add it to the list.
|
|
*/
|
|
struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
|
|
struct uwb_ie_drp *drp_ie)
|
|
{
|
|
struct uwb_rsv *rsv;
|
|
|
|
list_for_each_entry(rsv, &rc->reservations, rc_node) {
|
|
if (uwb_rsv_match(rsv, src, drp_ie))
|
|
return rsv;
|
|
}
|
|
|
|
if (uwb_ie_drp_owner(drp_ie))
|
|
return uwb_rsv_new_target(rc, src, drp_ie);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Go through all the reservations and check for timeouts and (if
|
|
* necessary) update their DRP IEs.
|
|
*
|
|
* FIXME: look at building the SET_DRP_IE command here rather than
|
|
* having to rescan the list in uwb_rc_send_all_drp_ie().
|
|
*/
|
|
static bool uwb_rsv_update_all(struct uwb_rc *rc)
|
|
{
|
|
struct uwb_rsv *rsv, *t;
|
|
bool ie_updated = false;
|
|
|
|
list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
|
|
if (rsv->expired)
|
|
uwb_drp_handle_timeout(rsv);
|
|
if (!rsv->ie_valid) {
|
|
uwb_drp_ie_update(rsv);
|
|
ie_updated = true;
|
|
}
|
|
}
|
|
|
|
return ie_updated;
|
|
}
|
|
|
|
void uwb_rsv_sched_update(struct uwb_rc *rc)
|
|
{
|
|
queue_work(rc->rsv_workq, &rc->rsv_update_work);
|
|
}
|
|
|
|
/*
|
|
* Update DRP IEs and, if necessary, the DRP Availability IE and send
|
|
* the updated IEs to the radio controller.
|
|
*/
|
|
static void uwb_rsv_update_work(struct work_struct *work)
|
|
{
|
|
struct uwb_rc *rc = container_of(work, struct uwb_rc, rsv_update_work);
|
|
bool ie_updated;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
|
|
ie_updated = uwb_rsv_update_all(rc);
|
|
|
|
if (!rc->drp_avail.ie_valid) {
|
|
uwb_drp_avail_ie_update(rc);
|
|
ie_updated = true;
|
|
}
|
|
|
|
if (ie_updated)
|
|
uwb_rc_send_all_drp_ie(rc);
|
|
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
}
|
|
|
|
static void uwb_rsv_timer(unsigned long arg)
|
|
{
|
|
struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
|
|
|
|
rsv->expired = true;
|
|
uwb_rsv_sched_update(rsv->rc);
|
|
}
|
|
|
|
void uwb_rsv_init(struct uwb_rc *rc)
|
|
{
|
|
INIT_LIST_HEAD(&rc->reservations);
|
|
mutex_init(&rc->rsvs_mutex);
|
|
INIT_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
|
|
|
|
bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
|
|
}
|
|
|
|
int uwb_rsv_setup(struct uwb_rc *rc)
|
|
{
|
|
char name[16];
|
|
|
|
snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
|
|
rc->rsv_workq = create_singlethread_workqueue(name);
|
|
if (rc->rsv_workq == NULL)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void uwb_rsv_cleanup(struct uwb_rc *rc)
|
|
{
|
|
struct uwb_rsv *rsv, *t;
|
|
|
|
mutex_lock(&rc->rsvs_mutex);
|
|
list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
|
|
uwb_rsv_remove(rsv);
|
|
}
|
|
mutex_unlock(&rc->rsvs_mutex);
|
|
|
|
cancel_work_sync(&rc->rsv_update_work);
|
|
destroy_workqueue(rc->rsv_workq);
|
|
}
|