/* * 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/kernel.h>#include <linux/slab.h>#include <linux/uwb.h> #include "uwb-internal.h" static void uwb_rsv_fill_column_alloc(struct uwb_rsv_alloc_info *ai){ int col, mas, safe_mas, unsafe_mas; unsigned char *bm = ai->bm; struct uwb_rsv_col_info *ci = ai->ci; unsigned char c; for (col = ci->csi.start_col; col < UWB_NUM_ZONES; col += ci->csi.interval) { safe_mas = ci->csi.safe_mas_per_col; unsafe_mas = ci->csi.unsafe_mas_per_col; for (mas = 0; mas < UWB_MAS_PER_ZONE; mas++ ) { if (bm[col * UWB_MAS_PER_ZONE + mas] == 0) { if (safe_mas > 0) { safe_mas--; c = UWB_RSV_MAS_SAFE; } else if (unsafe_mas > 0) { unsafe_mas--; c = UWB_RSV_MAS_UNSAFE; } else { break; } bm[col * UWB_MAS_PER_ZONE + mas] = c; } } }} static void uwb_rsv_fill_row_alloc(struct uwb_rsv_alloc_info *ai){ int mas, col, rows; unsigned char *bm = ai->bm; struct uwb_rsv_row_info *ri = &ai->ri; unsigned char c; rows = 1; c = UWB_RSV_MAS_SAFE; for (mas = UWB_MAS_PER_ZONE - 1; mas >= 0; mas--) { if (ri->avail[mas] == 1) { if (rows > ri->used_rows) { break; } else if (rows > 7) { c = UWB_RSV_MAS_UNSAFE; } for (col = 0; col < UWB_NUM_ZONES; col++) { if (bm[col * UWB_NUM_ZONES + mas] != UWB_RSV_MAS_NOT_AVAIL) { bm[col * UWB_NUM_ZONES + mas] = c; if(c == UWB_RSV_MAS_SAFE) ai->safe_allocated_mases++; else ai->unsafe_allocated_mases++; } } rows++; } } ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases;} /* * Find the best column set for a given availability, interval, num safe mas and * num unsafe mas. * * The different sets are tried in order as shown below, depending on the interval. * * interval = 16 * deep = 0 * set 1 -> { 8 } * deep = 1 * set 1 -> { 4 } * set 2 -> { 12 } * deep = 2 * set 1 -> { 2 } * set 2 -> { 6 } * set 3 -> { 10 } * set 4 -> { 14 } * deep = 3 * set 1 -> { 1 } * set 2 -> { 3 } * set 3 -> { 5 } * set 4 -> { 7 } * set 5 -> { 9 } * set 6 -> { 11 } * set 7 -> { 13 } * set 8 -> { 15 } * * interval = 8 * deep = 0 * set 1 -> { 4 12 } * deep = 1 * set 1 -> { 2 10 } * set 2 -> { 6 14 } * deep = 2 * set 1 -> { 1 9 } * set 2 -> { 3 11 } * set 3 -> { 5 13 } * set 4 -> { 7 15 } * * interval = 4 * deep = 0 * set 1 -> { 2 6 10 14 } * deep = 1 * set 1 -> { 1 5 9 13 } * set 2 -> { 3 7 11 15 } * * interval = 2 * deep = 0 * set 1 -> { 1 3 5 7 9 11 13 15 } */static int uwb_rsv_find_best_column_set(struct uwb_rsv_alloc_info *ai, int interval, int num_safe_mas, int num_unsafe_mas){ struct uwb_rsv_col_info *ci = ai->ci; struct uwb_rsv_col_set_info *csi = &ci->csi; struct uwb_rsv_col_set_info tmp_csi; int deep, set, col, start_col_deep, col_start_set; int start_col, max_mas_in_set, lowest_max_mas_in_deep; int n_mas; int found = UWB_RSV_ALLOC_NOT_FOUND; tmp_csi.start_col = 0; start_col_deep = interval; n_mas = num_unsafe_mas + num_safe_mas; for (deep = 0; ((interval >> deep) & 0x1) == 0; deep++) { start_col_deep /= 2; col_start_set = 0; lowest_max_mas_in_deep = UWB_MAS_PER_ZONE; for (set = 1; set <= (1 << deep); set++) { max_mas_in_set = 0; start_col = start_col_deep + col_start_set; for (col = start_col; col < UWB_NUM_ZONES; col += interval) { if (ci[col].max_avail_safe >= num_safe_mas && ci[col].max_avail_unsafe >= n_mas) { if (ci[col].highest_mas[n_mas] > max_mas_in_set) max_mas_in_set = ci[col].highest_mas[n_mas]; } else { max_mas_in_set = 0; break; } } if ((lowest_max_mas_in_deep > max_mas_in_set) && max_mas_in_set) { lowest_max_mas_in_deep = max_mas_in_set; tmp_csi.start_col = start_col; } col_start_set += (interval >> deep); } if (lowest_max_mas_in_deep < 8) { csi->start_col = tmp_csi.start_col; found = UWB_RSV_ALLOC_FOUND; break; } else if ((lowest_max_mas_in_deep > 8) && (lowest_max_mas_in_deep != UWB_MAS_PER_ZONE) && (found == UWB_RSV_ALLOC_NOT_FOUND)) { csi->start_col = tmp_csi.start_col; found = UWB_RSV_ALLOC_FOUND; } } if (found == UWB_RSV_ALLOC_FOUND) { csi->interval = interval; csi->safe_mas_per_col = num_safe_mas; csi->unsafe_mas_per_col = num_unsafe_mas; ai->safe_allocated_mases = (UWB_NUM_ZONES / interval) * num_safe_mas; ai->unsafe_allocated_mases = (UWB_NUM_ZONES / interval) * num_unsafe_mas; ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases; ai->interval = interval; } return found;} static void get_row_descriptors(struct uwb_rsv_alloc_info *ai){ unsigned char *bm = ai->bm; struct uwb_rsv_row_info *ri = &ai->ri; int col, mas; ri->free_rows = 16; for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) { ri->avail[mas] = 1; for (col = 1; col < UWB_NUM_ZONES; col++) { if (bm[col * UWB_NUM_ZONES + mas] == UWB_RSV_MAS_NOT_AVAIL) { ri->free_rows--; ri->avail[mas]=0; break; } } }} static void uwb_rsv_fill_column_info(unsigned char *bm, int column, struct uwb_rsv_col_info *rci){ int mas; int block_count = 0, start_block = 0; int previous_avail = 0; int available = 0; int safe_mas_in_row[UWB_MAS_PER_ZONE] = { 8, 7, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1, }; rci->max_avail_safe = 0; for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) { if (!bm[column * UWB_NUM_ZONES + mas]) { available++; rci->max_avail_unsafe = available; rci->highest_mas[available] = mas; if (previous_avail) { block_count++; if ((block_count > safe_mas_in_row[start_block]) && (!rci->max_avail_safe)) rci->max_avail_safe = available - 1; } else { previous_avail = 1; start_block = mas; block_count = 1; } } else { previous_avail = 0; } } if (!rci->max_avail_safe) rci->max_avail_safe = rci->max_avail_unsafe;} static void get_column_descriptors(struct uwb_rsv_alloc_info *ai){ unsigned char *bm = ai->bm; struct uwb_rsv_col_info *ci = ai->ci; int col; for (col = 1; col < UWB_NUM_ZONES; col++) { uwb_rsv_fill_column_info(bm, col, &ci[col]); }} static int uwb_rsv_find_best_row_alloc(struct uwb_rsv_alloc_info *ai){ int n_rows; int max_rows = ai->max_mas / UWB_USABLE_MAS_PER_ROW; int min_rows = ai->min_mas / UWB_USABLE_MAS_PER_ROW; if (ai->min_mas % UWB_USABLE_MAS_PER_ROW) min_rows++; for (n_rows = max_rows; n_rows >= min_rows; n_rows--) { if (n_rows <= ai->ri.free_rows) { ai->ri.used_rows = n_rows; ai->interval = 1; /* row reservation */ uwb_rsv_fill_row_alloc(ai); return UWB_RSV_ALLOC_FOUND; } } return UWB_RSV_ALLOC_NOT_FOUND;} static int uwb_rsv_find_best_col_alloc(struct uwb_rsv_alloc_info *ai, int interval){ int n_safe, n_unsafe, n_mas; int n_column = UWB_NUM_ZONES / interval; int max_per_zone = ai->max_mas / n_column; int min_per_zone = ai->min_mas / n_column; if (ai->min_mas % n_column) min_per_zone++; if (min_per_zone > UWB_MAS_PER_ZONE) { return UWB_RSV_ALLOC_NOT_FOUND; } if (max_per_zone > UWB_MAS_PER_ZONE) { max_per_zone = UWB_MAS_PER_ZONE; } for (n_mas = max_per_zone; n_mas >= min_per_zone; n_mas--) { if (uwb_rsv_find_best_column_set(ai, interval, 0, n_mas) == UWB_RSV_ALLOC_NOT_FOUND) continue; for (n_safe = n_mas; n_safe >= 0; n_safe--) { n_unsafe = n_mas - n_safe; if (uwb_rsv_find_best_column_set(ai, interval, n_safe, n_unsafe) == UWB_RSV_ALLOC_FOUND) { uwb_rsv_fill_column_alloc(ai); return UWB_RSV_ALLOC_FOUND; } } } return UWB_RSV_ALLOC_NOT_FOUND;} int uwb_rsv_find_best_allocation(struct uwb_rsv *rsv, struct uwb_mas_bm *available, struct uwb_mas_bm *result){ struct uwb_rsv_alloc_info *ai; int interval; int bit_index; ai = kzalloc(sizeof(struct uwb_rsv_alloc_info), GFP_KERNEL); if (!ai) return UWB_RSV_ALLOC_NOT_FOUND; ai->min_mas = rsv->min_mas; ai->max_mas = rsv->max_mas; ai->max_interval = rsv->max_interval; /* fill the not available vector from the available bm */ for_each_clear_bit(bit_index, available->bm, UWB_NUM_MAS) ai->bm[bit_index] = UWB_RSV_MAS_NOT_AVAIL; if (ai->max_interval == 1) { get_row_descriptors(ai); if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND) goto alloc_found; else goto alloc_not_found; } get_column_descriptors(ai); for (interval = 16; interval >= 2; interval>>=1) { if (interval > ai->max_interval) continue; if (uwb_rsv_find_best_col_alloc(ai, interval) == UWB_RSV_ALLOC_FOUND) goto alloc_found; } /* try row reservation if no column is found */ get_row_descriptors(ai); if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND) goto alloc_found; else goto alloc_not_found; alloc_found: bitmap_zero(result->bm, UWB_NUM_MAS); bitmap_zero(result->unsafe_bm, UWB_NUM_MAS); /* fill the safe and unsafe bitmaps */ for (bit_index = 0; bit_index < UWB_NUM_MAS; bit_index++) { if (ai->bm[bit_index] == UWB_RSV_MAS_SAFE) set_bit(bit_index, result->bm); else if (ai->bm[bit_index] == UWB_RSV_MAS_UNSAFE) set_bit(bit_index, result->unsafe_bm); } bitmap_or(result->bm, result->bm, result->unsafe_bm, UWB_NUM_MAS); result->safe = ai->safe_allocated_mases; result->unsafe = ai->unsafe_allocated_mases; kfree(ai); return UWB_RSV_ALLOC_FOUND; alloc_not_found: kfree(ai); return UWB_RSV_ALLOC_NOT_FOUND;}
/*
* 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/kernel.h>
#include <linux/slab.h>
#include <linux/uwb.h>
#include "uwb-internal.h"
static void uwb_rsv_fill_column_alloc(struct uwb_rsv_alloc_info *ai)
{
int col, mas, safe_mas, unsafe_mas;
unsigned char *bm = ai->bm;
struct uwb_rsv_col_info *ci = ai->ci;
unsigned char c;
for (col = ci->csi.start_col; col < UWB_NUM_ZONES; col += ci->csi.interval) {
safe_mas = ci->csi.safe_mas_per_col;
unsafe_mas = ci->csi.unsafe_mas_per_col;
for (mas = 0; mas < UWB_MAS_PER_ZONE; mas++ ) {
if (bm[col * UWB_MAS_PER_ZONE + mas] == 0) {
if (safe_mas > 0) {
safe_mas--;
c = UWB_RSV_MAS_SAFE;
} else if (unsafe_mas > 0) {
unsafe_mas--;
c = UWB_RSV_MAS_UNSAFE;
} else {
break;
}
bm[col * UWB_MAS_PER_ZONE + mas] = c;
}
}
}
}
static void uwb_rsv_fill_row_alloc(struct uwb_rsv_alloc_info *ai)
{
int mas, col, rows;
unsigned char *bm = ai->bm;
struct uwb_rsv_row_info *ri = &ai->ri;
unsigned char c;
rows = 1;
c = UWB_RSV_MAS_SAFE;
for (mas = UWB_MAS_PER_ZONE - 1; mas >= 0; mas--) {
if (ri->avail[mas] == 1) {
if (rows > ri->used_rows) {
break;
} else if (rows > 7) {
c = UWB_RSV_MAS_UNSAFE;
}
for (col = 0; col < UWB_NUM_ZONES; col++) {
if (bm[col * UWB_NUM_ZONES + mas] != UWB_RSV_MAS_NOT_AVAIL) {
bm[col * UWB_NUM_ZONES + mas] = c;
if(c == UWB_RSV_MAS_SAFE)
ai->safe_allocated_mases++;
else
ai->unsafe_allocated_mases++;
}
}
rows++;
}
}
ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases;
}
/*
* Find the best column set for a given availability, interval, num safe mas and
* num unsafe mas.
*
* The different sets are tried in order as shown below, depending on the interval.
*
* interval = 16
* deep = 0
* set 1 -> { 8 }
* deep = 1
* set 1 -> { 4 }
* set 2 -> { 12 }
* deep = 2
* set 1 -> { 2 }
* set 2 -> { 6 }
* set 3 -> { 10 }
* set 4 -> { 14 }
* deep = 3
* set 1 -> { 1 }
* set 2 -> { 3 }
* set 3 -> { 5 }
* set 4 -> { 7 }
* set 5 -> { 9 }
* set 6 -> { 11 }
* set 7 -> { 13 }
* set 8 -> { 15 }
*
* interval = 8
* deep = 0
* set 1 -> { 4 12 }
* deep = 1
* set 1 -> { 2 10 }
* set 2 -> { 6 14 }
* deep = 2
* set 1 -> { 1 9 }
* set 2 -> { 3 11 }
* set 3 -> { 5 13 }
* set 4 -> { 7 15 }
*
* interval = 4
* deep = 0
* set 1 -> { 2 6 10 14 }
* deep = 1
* set 1 -> { 1 5 9 13 }
* set 2 -> { 3 7 11 15 }
*
* interval = 2
* deep = 0
* set 1 -> { 1 3 5 7 9 11 13 15 }
*/
static int uwb_rsv_find_best_column_set(struct uwb_rsv_alloc_info *ai, int interval,
int num_safe_mas, int num_unsafe_mas)
{
struct uwb_rsv_col_info *ci = ai->ci;
struct uwb_rsv_col_set_info *csi = &ci->csi;
struct uwb_rsv_col_set_info tmp_csi;
int deep, set, col, start_col_deep, col_start_set;
int start_col, max_mas_in_set, lowest_max_mas_in_deep;
int n_mas;
int found = UWB_RSV_ALLOC_NOT_FOUND;
tmp_csi.start_col = 0;
start_col_deep = interval;
n_mas = num_unsafe_mas + num_safe_mas;
for (deep = 0; ((interval >> deep) & 0x1) == 0; deep++) {
start_col_deep /= 2;
col_start_set = 0;
lowest_max_mas_in_deep = UWB_MAS_PER_ZONE;
for (set = 1; set <= (1 << deep); set++) {
max_mas_in_set = 0;
start_col = start_col_deep + col_start_set;
for (col = start_col; col < UWB_NUM_ZONES; col += interval) {
if (ci[col].max_avail_safe >= num_safe_mas &&
ci[col].max_avail_unsafe >= n_mas) {
if (ci[col].highest_mas[n_mas] > max_mas_in_set)
max_mas_in_set = ci[col].highest_mas[n_mas];
} else {
max_mas_in_set = 0;
break;
}
}
if ((lowest_max_mas_in_deep > max_mas_in_set) && max_mas_in_set) {
lowest_max_mas_in_deep = max_mas_in_set;
tmp_csi.start_col = start_col;
}
col_start_set += (interval >> deep);
}
if (lowest_max_mas_in_deep < 8) {
csi->start_col = tmp_csi.start_col;
found = UWB_RSV_ALLOC_FOUND;
break;
} else if ((lowest_max_mas_in_deep > 8) &&
(lowest_max_mas_in_deep != UWB_MAS_PER_ZONE) &&
(found == UWB_RSV_ALLOC_NOT_FOUND)) {
csi->start_col = tmp_csi.start_col;
found = UWB_RSV_ALLOC_FOUND;
}
}
if (found == UWB_RSV_ALLOC_FOUND) {
csi->interval = interval;
csi->safe_mas_per_col = num_safe_mas;
csi->unsafe_mas_per_col = num_unsafe_mas;
ai->safe_allocated_mases = (UWB_NUM_ZONES / interval) * num_safe_mas;
ai->unsafe_allocated_mases = (UWB_NUM_ZONES / interval) * num_unsafe_mas;
ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases;
ai->interval = interval;
}
return found;
}
static void get_row_descriptors(struct uwb_rsv_alloc_info *ai)
{
unsigned char *bm = ai->bm;
struct uwb_rsv_row_info *ri = &ai->ri;
int col, mas;
ri->free_rows = 16;
for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) {
ri->avail[mas] = 1;
for (col = 1; col < UWB_NUM_ZONES; col++) {
if (bm[col * UWB_NUM_ZONES + mas] == UWB_RSV_MAS_NOT_AVAIL) {
ri->free_rows--;
ri->avail[mas]=0;
break;
}
}
}
}
static void uwb_rsv_fill_column_info(unsigned char *bm, int column, struct uwb_rsv_col_info *rci)
{
int mas;
int block_count = 0, start_block = 0;
int previous_avail = 0;
int available = 0;
int safe_mas_in_row[UWB_MAS_PER_ZONE] = {
8, 7, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1,
};
rci->max_avail_safe = 0;
for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) {
if (!bm[column * UWB_NUM_ZONES + mas]) {
available++;
rci->max_avail_unsafe = available;
rci->highest_mas[available] = mas;
if (previous_avail) {
block_count++;
if ((block_count > safe_mas_in_row[start_block]) &&
(!rci->max_avail_safe))
rci->max_avail_safe = available - 1;
} else {
previous_avail = 1;
start_block = mas;
block_count = 1;
}
} else {
previous_avail = 0;
}
}
if (!rci->max_avail_safe)
rci->max_avail_safe = rci->max_avail_unsafe;
}
static void get_column_descriptors(struct uwb_rsv_alloc_info *ai)
{
unsigned char *bm = ai->bm;
struct uwb_rsv_col_info *ci = ai->ci;
int col;
for (col = 1; col < UWB_NUM_ZONES; col++) {
uwb_rsv_fill_column_info(bm, col, &ci[col]);
}
}
static int uwb_rsv_find_best_row_alloc(struct uwb_rsv_alloc_info *ai)
{
int n_rows;
int max_rows = ai->max_mas / UWB_USABLE_MAS_PER_ROW;
int min_rows = ai->min_mas / UWB_USABLE_MAS_PER_ROW;
if (ai->min_mas % UWB_USABLE_MAS_PER_ROW)
min_rows++;
for (n_rows = max_rows; n_rows >= min_rows; n_rows--) {
if (n_rows <= ai->ri.free_rows) {
ai->ri.used_rows = n_rows;
ai->interval = 1; /* row reservation */
uwb_rsv_fill_row_alloc(ai);
return UWB_RSV_ALLOC_FOUND;
}
}
return UWB_RSV_ALLOC_NOT_FOUND;
}
static int uwb_rsv_find_best_col_alloc(struct uwb_rsv_alloc_info *ai, int interval)
{
int n_safe, n_unsafe, n_mas;
int n_column = UWB_NUM_ZONES / interval;
int max_per_zone = ai->max_mas / n_column;
int min_per_zone = ai->min_mas / n_column;
if (ai->min_mas % n_column)
min_per_zone++;
if (min_per_zone > UWB_MAS_PER_ZONE) {
return UWB_RSV_ALLOC_NOT_FOUND;
}
if (max_per_zone > UWB_MAS_PER_ZONE) {
max_per_zone = UWB_MAS_PER_ZONE;
}
for (n_mas = max_per_zone; n_mas >= min_per_zone; n_mas--) {
if (uwb_rsv_find_best_column_set(ai, interval, 0, n_mas) == UWB_RSV_ALLOC_NOT_FOUND)
continue;
for (n_safe = n_mas; n_safe >= 0; n_safe--) {
n_unsafe = n_mas - n_safe;
if (uwb_rsv_find_best_column_set(ai, interval, n_safe, n_unsafe) == UWB_RSV_ALLOC_FOUND) {
uwb_rsv_fill_column_alloc(ai);
return UWB_RSV_ALLOC_FOUND;
}
}
}
return UWB_RSV_ALLOC_NOT_FOUND;
}
int uwb_rsv_find_best_allocation(struct uwb_rsv *rsv, struct uwb_mas_bm *available,
struct uwb_mas_bm *result)
{
struct uwb_rsv_alloc_info *ai;
int interval;
int bit_index;
ai = kzalloc(sizeof(struct uwb_rsv_alloc_info), GFP_KERNEL);
if (!ai)
return UWB_RSV_ALLOC_NOT_FOUND;
ai->min_mas = rsv->min_mas;
ai->max_mas = rsv->max_mas;
ai->max_interval = rsv->max_interval;
/* fill the not available vector from the available bm */
for_each_clear_bit(bit_index, available->bm, UWB_NUM_MAS)
ai->bm[bit_index] = UWB_RSV_MAS_NOT_AVAIL;
if (ai->max_interval == 1) {
get_row_descriptors(ai);
if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND)
goto alloc_found;
else
goto alloc_not_found;
}
get_column_descriptors(ai);
for (interval = 16; interval >= 2; interval>>=1) {
if (interval > ai->max_interval)
continue;
if (uwb_rsv_find_best_col_alloc(ai, interval) == UWB_RSV_ALLOC_FOUND)
goto alloc_found;
}
/* try row reservation if no column is found */
get_row_descriptors(ai);
if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND)
goto alloc_found;
else
goto alloc_not_found;
alloc_found:
bitmap_zero(result->bm, UWB_NUM_MAS);
bitmap_zero(result->unsafe_bm, UWB_NUM_MAS);
/* fill the safe and unsafe bitmaps */
for (bit_index = 0; bit_index < UWB_NUM_MAS; bit_index++) {
if (ai->bm[bit_index] == UWB_RSV_MAS_SAFE)
set_bit(bit_index, result->bm);
else if (ai->bm[bit_index] == UWB_RSV_MAS_UNSAFE)
set_bit(bit_index, result->unsafe_bm);
}
bitmap_or(result->bm, result->bm, result->unsafe_bm, UWB_NUM_MAS);
result->safe = ai->safe_allocated_mases;
result->unsafe = ai->unsafe_allocated_mases;
kfree(ai);
return UWB_RSV_ALLOC_FOUND;
alloc_not_found:
kfree(ai);
return UWB_RSV_ALLOC_NOT_FOUND;
}