388 lines
10 KiB
C
388 lines
10 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/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 (bit_index = 0; bit_index < UWB_NUM_MAS; bit_index++) {
|
|
if (!test_bit(bit_index, available->bm))
|
|
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;
|
|
}
|