Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
[linux-2.6.git] / drivers / uwb / allocator.c
1 /*
2  * UWB reservation management.
3  *
4  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version
8  * 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 #include <linux/kernel.h>
19 #include <linux/uwb.h>
20
21 #include "uwb-internal.h"
22
23 static void uwb_rsv_fill_column_alloc(struct uwb_rsv_alloc_info *ai)
24 {
25         int col, mas, safe_mas, unsafe_mas;
26         unsigned char *bm = ai->bm;
27         struct uwb_rsv_col_info *ci = ai->ci;
28         unsigned char c;
29
30         for (col = ci->csi.start_col; col < UWB_NUM_ZONES; col += ci->csi.interval) {
31     
32                 safe_mas   = ci->csi.safe_mas_per_col;
33                 unsafe_mas = ci->csi.unsafe_mas_per_col;
34     
35                 for (mas = 0; mas < UWB_MAS_PER_ZONE; mas++ ) {
36                         if (bm[col * UWB_MAS_PER_ZONE + mas] == 0) {
37         
38                                 if (safe_mas > 0) {
39                                         safe_mas--;
40                                         c = UWB_RSV_MAS_SAFE;
41                                 } else if (unsafe_mas > 0) {
42                                         unsafe_mas--;
43                                         c = UWB_RSV_MAS_UNSAFE;
44                                 } else {
45                                         break;
46                                 }
47                                 bm[col * UWB_MAS_PER_ZONE + mas] = c;
48                         }
49                 }
50         }
51 }
52
53 static void uwb_rsv_fill_row_alloc(struct uwb_rsv_alloc_info *ai)
54 {
55         int mas, col, rows;
56         unsigned char *bm = ai->bm;
57         struct uwb_rsv_row_info *ri = &ai->ri;
58         unsigned char c;
59
60         rows = 1;
61         c = UWB_RSV_MAS_SAFE;
62         for (mas = UWB_MAS_PER_ZONE - 1; mas >= 0; mas--) {
63                 if (ri->avail[mas] == 1) {
64       
65                         if (rows > ri->used_rows) {
66                                 break;
67                         } else if (rows > 7) {
68                                 c = UWB_RSV_MAS_UNSAFE;
69                         }
70
71                         for (col = 0; col < UWB_NUM_ZONES; col++) {
72                                 if (bm[col * UWB_NUM_ZONES + mas] != UWB_RSV_MAS_NOT_AVAIL) {
73                                         bm[col * UWB_NUM_ZONES + mas] = c;
74                                         if(c == UWB_RSV_MAS_SAFE)
75                                                 ai->safe_allocated_mases++;
76                                         else
77                                                 ai->unsafe_allocated_mases++;
78                                 }
79                         }
80                         rows++;
81                 }
82         }
83         ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases;
84 }
85
86 /*
87  * Find the best column set for a given availability, interval, num safe mas and
88  * num unsafe mas.
89  *
90  * The different sets are tried in order as shown below, depending on the interval.
91  *
92  * interval = 16
93  *      deep = 0
94  *              set 1 ->  {  8 }
95  *      deep = 1
96  *              set 1 ->  {  4 }
97  *              set 2 ->  { 12 }
98  *      deep = 2
99  *              set 1 ->  {  2 }
100  *              set 2 ->  {  6 }
101  *              set 3 ->  { 10 }
102  *              set 4 ->  { 14 }
103  *      deep = 3
104  *              set 1 ->  {  1 }
105  *              set 2 ->  {  3 }
106  *              set 3 ->  {  5 }
107  *              set 4 ->  {  7 }
108  *              set 5 ->  {  9 }
109  *              set 6 ->  { 11 }
110  *              set 7 ->  { 13 }
111  *              set 8 ->  { 15 }
112  *
113  * interval = 8
114  *      deep = 0
115  *              set 1 ->  {  4  12 }
116  *      deep = 1
117  *              set 1 ->  {  2  10 }
118  *              set 2 ->  {  6  14 }
119  *      deep = 2
120  *              set 1 ->  {  1   9 }
121  *              set 2 ->  {  3  11 }
122  *              set 3 ->  {  5  13 }
123  *              set 4 ->  {  7  15 }
124  *
125  * interval = 4
126  *      deep = 0
127  *              set 1 ->  {  2   6  10  14 }
128  *      deep = 1
129  *              set 1 ->  {  1   5   9  13 }
130  *              set 2 ->  {  3   7  11  15 }
131  *
132  * interval = 2
133  *      deep = 0
134  *              set 1 ->  {  1   3   5   7   9  11  13  15 }
135  */
136 static int uwb_rsv_find_best_column_set(struct uwb_rsv_alloc_info *ai, int interval, 
137                                         int num_safe_mas, int num_unsafe_mas)
138 {
139         struct uwb_rsv_col_info *ci = ai->ci;
140         struct uwb_rsv_col_set_info *csi = &ci->csi;
141         struct uwb_rsv_col_set_info tmp_csi;
142         int deep, set, col, start_col_deep, col_start_set;
143         int start_col, max_mas_in_set, lowest_max_mas_in_deep;
144         int n_mas;
145         int found = UWB_RSV_ALLOC_NOT_FOUND; 
146
147         tmp_csi.start_col = 0;
148         start_col_deep = interval;
149         n_mas = num_unsafe_mas + num_safe_mas;
150
151         for (deep = 0; ((interval >> deep) & 0x1) == 0; deep++) {
152                 start_col_deep /= 2;
153                 col_start_set = 0;
154                 lowest_max_mas_in_deep = UWB_MAS_PER_ZONE;
155
156                 for (set = 1; set <= (1 << deep); set++) {
157                         max_mas_in_set = 0;
158                         start_col = start_col_deep + col_start_set;
159                         for (col = start_col; col < UWB_NUM_ZONES; col += interval) {
160                 
161                                 if (ci[col].max_avail_safe >= num_safe_mas &&
162                                     ci[col].max_avail_unsafe >= n_mas) {
163                                         if (ci[col].highest_mas[n_mas] > max_mas_in_set)
164                                                 max_mas_in_set = ci[col].highest_mas[n_mas];
165                                 } else {
166                                         max_mas_in_set = 0;
167                                         break;
168                                 }
169                         }
170                         if ((lowest_max_mas_in_deep > max_mas_in_set) && max_mas_in_set) {
171                                 lowest_max_mas_in_deep = max_mas_in_set;
172
173                                 tmp_csi.start_col = start_col;
174                         }
175                         col_start_set += (interval >> deep);
176                 }
177
178                 if (lowest_max_mas_in_deep < 8) {
179                         csi->start_col = tmp_csi.start_col;
180                         found = UWB_RSV_ALLOC_FOUND;
181                         break;
182                 } else if ((lowest_max_mas_in_deep > 8) && 
183                            (lowest_max_mas_in_deep != UWB_MAS_PER_ZONE) &&
184                            (found == UWB_RSV_ALLOC_NOT_FOUND)) {
185                         csi->start_col = tmp_csi.start_col;
186                         found = UWB_RSV_ALLOC_FOUND;
187                 }
188         }
189
190         if (found == UWB_RSV_ALLOC_FOUND) {
191                 csi->interval = interval;
192                 csi->safe_mas_per_col = num_safe_mas;
193                 csi->unsafe_mas_per_col = num_unsafe_mas;
194
195                 ai->safe_allocated_mases = (UWB_NUM_ZONES / interval) * num_safe_mas;
196                 ai->unsafe_allocated_mases = (UWB_NUM_ZONES / interval) * num_unsafe_mas;
197                 ai->total_allocated_mases = ai->safe_allocated_mases + ai->unsafe_allocated_mases;
198                 ai->interval = interval;                
199         }
200         return found;
201 }
202
203 static void get_row_descriptors(struct uwb_rsv_alloc_info *ai)
204 {
205         unsigned char *bm = ai->bm;
206         struct uwb_rsv_row_info *ri = &ai->ri;
207         int col, mas;
208   
209         ri->free_rows = 16;
210         for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) {
211                 ri->avail[mas] = 1;
212                 for (col = 1; col < UWB_NUM_ZONES; col++) {
213                         if (bm[col * UWB_NUM_ZONES + mas] == UWB_RSV_MAS_NOT_AVAIL) {
214                                 ri->free_rows--;
215                                 ri->avail[mas]=0;
216                                 break;
217                         }
218                 }
219         }
220 }
221
222 static void uwb_rsv_fill_column_info(unsigned char *bm, int column, struct uwb_rsv_col_info *rci)
223 {
224         int mas;
225         int block_count = 0, start_block = 0; 
226         int previous_avail = 0;
227         int available = 0;
228         int safe_mas_in_row[UWB_MAS_PER_ZONE] = {
229                 8, 7, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1,
230         };
231
232         rci->max_avail_safe = 0;
233
234         for (mas = 0; mas < UWB_MAS_PER_ZONE; mas ++) {
235                 if (!bm[column * UWB_NUM_ZONES + mas]) {
236                         available++;
237                         rci->max_avail_unsafe = available;
238
239                         rci->highest_mas[available] = mas;
240
241                         if (previous_avail) {
242                                 block_count++;
243                                 if ((block_count > safe_mas_in_row[start_block]) &&
244                                     (!rci->max_avail_safe))
245                                         rci->max_avail_safe = available - 1;
246                         } else {
247                                 previous_avail = 1;
248                                 start_block = mas;
249                                 block_count = 1;
250                         }
251                 } else {
252                         previous_avail = 0;
253                 }
254         }
255         if (!rci->max_avail_safe)
256                 rci->max_avail_safe = rci->max_avail_unsafe;
257 }
258
259 static void get_column_descriptors(struct uwb_rsv_alloc_info *ai)
260 {
261         unsigned char *bm = ai->bm;
262         struct uwb_rsv_col_info *ci = ai->ci;
263         int col;
264
265         for (col = 1; col < UWB_NUM_ZONES; col++) {
266                 uwb_rsv_fill_column_info(bm, col, &ci[col]);
267         }
268 }
269
270 static int uwb_rsv_find_best_row_alloc(struct uwb_rsv_alloc_info *ai)
271 {
272         int n_rows;
273         int max_rows = ai->max_mas / UWB_USABLE_MAS_PER_ROW;
274         int min_rows = ai->min_mas / UWB_USABLE_MAS_PER_ROW;
275         if (ai->min_mas % UWB_USABLE_MAS_PER_ROW)
276                 min_rows++;
277         for (n_rows = max_rows; n_rows >= min_rows; n_rows--) {
278                 if (n_rows <= ai->ri.free_rows) {
279                         ai->ri.used_rows = n_rows;
280                         ai->interval = 1; /* row reservation */
281                         uwb_rsv_fill_row_alloc(ai);
282                         return UWB_RSV_ALLOC_FOUND;
283                 }
284         }  
285         return UWB_RSV_ALLOC_NOT_FOUND;
286 }
287
288 static int uwb_rsv_find_best_col_alloc(struct uwb_rsv_alloc_info *ai, int interval)
289 {
290         int n_safe, n_unsafe, n_mas;  
291         int n_column = UWB_NUM_ZONES / interval;
292         int max_per_zone = ai->max_mas / n_column;
293         int min_per_zone = ai->min_mas / n_column;
294
295         if (ai->min_mas % n_column)
296                 min_per_zone++;
297
298         if (min_per_zone > UWB_MAS_PER_ZONE) {
299                 return UWB_RSV_ALLOC_NOT_FOUND;
300         }
301     
302         if (max_per_zone > UWB_MAS_PER_ZONE) {
303                 max_per_zone = UWB_MAS_PER_ZONE;
304         }
305     
306         for (n_mas = max_per_zone; n_mas >= min_per_zone; n_mas--) {
307                 if (uwb_rsv_find_best_column_set(ai, interval, 0, n_mas) == UWB_RSV_ALLOC_NOT_FOUND)
308                         continue;
309                 for (n_safe = n_mas; n_safe >= 0; n_safe--) {
310                         n_unsafe = n_mas - n_safe;
311                         if (uwb_rsv_find_best_column_set(ai, interval, n_safe, n_unsafe) == UWB_RSV_ALLOC_FOUND) {
312                                 uwb_rsv_fill_column_alloc(ai);
313                                 return UWB_RSV_ALLOC_FOUND;
314                         }
315                 }
316         }
317         return UWB_RSV_ALLOC_NOT_FOUND;
318 }
319
320 int uwb_rsv_find_best_allocation(struct uwb_rsv *rsv, struct uwb_mas_bm *available, 
321                                  struct uwb_mas_bm *result)
322 {
323         struct uwb_rsv_alloc_info *ai;
324         int interval;
325         int bit_index;
326
327         ai = kzalloc(sizeof(struct uwb_rsv_alloc_info), GFP_KERNEL);
328         
329         ai->min_mas = rsv->min_mas;
330         ai->max_mas = rsv->max_mas;
331         ai->max_interval = rsv->max_interval;
332
333
334         /* fill the not available vector from the available bm */
335         for (bit_index = 0; bit_index < UWB_NUM_MAS; bit_index++) {
336                 if (!test_bit(bit_index, available->bm))
337                         ai->bm[bit_index] = UWB_RSV_MAS_NOT_AVAIL;
338         }
339
340         if (ai->max_interval == 1) {
341                 get_row_descriptors(ai);
342                 if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND)
343                         goto alloc_found;
344                 else
345                         goto alloc_not_found;
346         }
347
348         get_column_descriptors(ai);
349         
350         for (interval = 16; interval >= 2; interval>>=1) {
351                 if (interval > ai->max_interval)
352                         continue;
353                 if (uwb_rsv_find_best_col_alloc(ai, interval) == UWB_RSV_ALLOC_FOUND)
354                         goto alloc_found;
355         }
356
357         /* try row reservation if no column is found */
358         get_row_descriptors(ai);
359         if (uwb_rsv_find_best_row_alloc(ai) == UWB_RSV_ALLOC_FOUND)
360                 goto alloc_found;
361         else
362                 goto alloc_not_found;
363
364   alloc_found:
365         bitmap_zero(result->bm, UWB_NUM_MAS);
366         bitmap_zero(result->unsafe_bm, UWB_NUM_MAS);
367         /* fill the safe and unsafe bitmaps */
368         for (bit_index = 0; bit_index < UWB_NUM_MAS; bit_index++) {
369                 if (ai->bm[bit_index] == UWB_RSV_MAS_SAFE)
370                         set_bit(bit_index, result->bm);
371                 else if (ai->bm[bit_index] == UWB_RSV_MAS_UNSAFE)
372                         set_bit(bit_index, result->unsafe_bm);
373         }
374         bitmap_or(result->bm, result->bm, result->unsafe_bm, UWB_NUM_MAS);
375
376         result->safe   = ai->safe_allocated_mases;
377         result->unsafe = ai->unsafe_allocated_mases;
378         
379         kfree(ai);              
380         return UWB_RSV_ALLOC_FOUND;
381   
382   alloc_not_found:
383         kfree(ai);
384         return UWB_RSV_ALLOC_NOT_FOUND;
385 }