drp-ie.c

Go to the documentation of this file.

/*
 * UWB DRP IE management.
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * 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/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.
 */
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 .
 */
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(sizeof(struct uwb_ie_drp) +
            UWB_NUM_ZONES * sizeof(struct uwb_drp_alloc),
            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);
}

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);
    }
}

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);
        }
    }
}