blob: 6b76f4bb4cc7dc5a25da658c0cc2d006ba3662f0 [file] [log] [blame]
David Vrabel8cc13a02008-09-17 16:34:09 +01001/*
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 */
David Vrabel8cc13a02008-09-17 16:34:09 +010018#include <linux/kernel.h>
19#include <linux/uwb.h>
Stefano Panella5b377172008-12-12 13:00:06 +000020#include <linux/random.h>
David Vrabel8cc13a02008-09-17 16:34:09 +010021
22#include "uwb-internal.h"
23
24static void uwb_rsv_timer(unsigned long arg);
25
26static const char *rsv_states[] = {
Stefano Panella5b377172008-12-12 13:00:06 +000027 [UWB_RSV_STATE_NONE] = "none ",
28 [UWB_RSV_STATE_O_INITIATED] = "o initiated ",
29 [UWB_RSV_STATE_O_PENDING] = "o pending ",
30 [UWB_RSV_STATE_O_MODIFIED] = "o modified ",
31 [UWB_RSV_STATE_O_ESTABLISHED] = "o established ",
32 [UWB_RSV_STATE_O_TO_BE_MOVED] = "o to be moved ",
33 [UWB_RSV_STATE_O_MOVE_EXPANDING] = "o move expanding",
34 [UWB_RSV_STATE_O_MOVE_COMBINING] = "o move combining",
35 [UWB_RSV_STATE_O_MOVE_REDUCING] = "o move reducing ",
36 [UWB_RSV_STATE_T_ACCEPTED] = "t accepted ",
37 [UWB_RSV_STATE_T_CONFLICT] = "t conflict ",
38 [UWB_RSV_STATE_T_PENDING] = "t pending ",
39 [UWB_RSV_STATE_T_DENIED] = "t denied ",
40 [UWB_RSV_STATE_T_RESIZED] = "t resized ",
41 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = "t expanding acc ",
42 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = "t expanding conf",
43 [UWB_RSV_STATE_T_EXPANDING_PENDING] = "t expanding pend",
44 [UWB_RSV_STATE_T_EXPANDING_DENIED] = "t expanding den ",
David Vrabel8cc13a02008-09-17 16:34:09 +010045};
46
47static const char *rsv_types[] = {
48 [UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
49 [UWB_DRP_TYPE_HARD] = "hard",
50 [UWB_DRP_TYPE_SOFT] = "soft",
51 [UWB_DRP_TYPE_PRIVATE] = "private",
52 [UWB_DRP_TYPE_PCA] = "pca",
53};
54
Stefano Panella5b377172008-12-12 13:00:06 +000055bool uwb_rsv_has_two_drp_ies(struct uwb_rsv *rsv)
56{
57 static const bool has_two_drp_ies[] = {
58 [UWB_RSV_STATE_O_INITIATED] = false,
59 [UWB_RSV_STATE_O_PENDING] = false,
60 [UWB_RSV_STATE_O_MODIFIED] = false,
61 [UWB_RSV_STATE_O_ESTABLISHED] = false,
62 [UWB_RSV_STATE_O_TO_BE_MOVED] = false,
63 [UWB_RSV_STATE_O_MOVE_COMBINING] = false,
64 [UWB_RSV_STATE_O_MOVE_REDUCING] = false,
65 [UWB_RSV_STATE_O_MOVE_EXPANDING] = true,
66 [UWB_RSV_STATE_T_ACCEPTED] = false,
67 [UWB_RSV_STATE_T_CONFLICT] = false,
68 [UWB_RSV_STATE_T_PENDING] = false,
69 [UWB_RSV_STATE_T_DENIED] = false,
70 [UWB_RSV_STATE_T_RESIZED] = false,
71 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = true,
72 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = true,
73 [UWB_RSV_STATE_T_EXPANDING_PENDING] = true,
74 [UWB_RSV_STATE_T_EXPANDING_DENIED] = true,
75 };
76
77 return has_two_drp_ies[rsv->state];
78}
79
David Vrabel8cc13a02008-09-17 16:34:09 +010080/**
81 * uwb_rsv_state_str - return a string for a reservation state
82 * @state: the reservation state.
83 */
84const char *uwb_rsv_state_str(enum uwb_rsv_state state)
85{
86 if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
87 return "unknown";
88 return rsv_states[state];
89}
90EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
91
92/**
93 * uwb_rsv_type_str - return a string for a reservation type
94 * @type: the reservation type
95 */
96const char *uwb_rsv_type_str(enum uwb_drp_type type)
97{
98 if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
99 return "invalid";
100 return rsv_types[type];
101}
102EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
103
Stefano Panella5b377172008-12-12 13:00:06 +0000104void uwb_rsv_dump(char *text, struct uwb_rsv *rsv)
David Vrabel8cc13a02008-09-17 16:34:09 +0100105{
106 struct device *dev = &rsv->rc->uwb_dev.dev;
107 struct uwb_dev_addr devaddr;
108 char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
109
110 uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
111 if (rsv->target.type == UWB_RSV_TARGET_DEV)
112 devaddr = rsv->target.dev->dev_addr;
113 else
114 devaddr = rsv->target.devaddr;
115 uwb_dev_addr_print(target, sizeof(target), &devaddr);
116
David Vrabel2226b1c2009-01-06 17:55:32 +0000117 dev_dbg(dev, "rsv %s %s -> %s: %s\n",
118 text, owner, target, uwb_rsv_state_str(rsv->state));
David Vrabel8cc13a02008-09-17 16:34:09 +0100119}
120
David Vrabelcae1c112008-10-27 15:22:46 +0000121static void uwb_rsv_release(struct kref *kref)
122{
123 struct uwb_rsv *rsv = container_of(kref, struct uwb_rsv, kref);
124
125 kfree(rsv);
126}
127
Stefano Panella5b377172008-12-12 13:00:06 +0000128void uwb_rsv_get(struct uwb_rsv *rsv)
David Vrabelcae1c112008-10-27 15:22:46 +0000129{
130 kref_get(&rsv->kref);
131}
132
Stefano Panella5b377172008-12-12 13:00:06 +0000133void uwb_rsv_put(struct uwb_rsv *rsv)
David Vrabelcae1c112008-10-27 15:22:46 +0000134{
135 kref_put(&rsv->kref, uwb_rsv_release);
136}
137
David Vrabel8cc13a02008-09-17 16:34:09 +0100138/*
139 * Get a free stream index for a reservation.
140 *
141 * If the target is a DevAddr (e.g., a WUSB cluster reservation) then
142 * the stream is allocated from a pool of per-RC stream indexes,
143 * otherwise a unique stream index for the target is selected.
144 */
145static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
146{
147 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000148 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100149 unsigned long *streams_bm;
150 int stream;
151
152 switch (rsv->target.type) {
153 case UWB_RSV_TARGET_DEV:
154 streams_bm = rsv->target.dev->streams;
155 break;
156 case UWB_RSV_TARGET_DEVADDR:
157 streams_bm = rc->uwb_dev.streams;
158 break;
159 default:
160 return -EINVAL;
161 }
162
163 stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
164 if (stream >= UWB_NUM_STREAMS)
165 return -EBUSY;
166
167 rsv->stream = stream;
168 set_bit(stream, streams_bm);
169
Stefano Panella5b377172008-12-12 13:00:06 +0000170 dev_dbg(dev, "get stream %d\n", rsv->stream);
171
David Vrabel8cc13a02008-09-17 16:34:09 +0100172 return 0;
173}
174
175static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
176{
177 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000178 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100179 unsigned long *streams_bm;
180
181 switch (rsv->target.type) {
182 case UWB_RSV_TARGET_DEV:
183 streams_bm = rsv->target.dev->streams;
184 break;
185 case UWB_RSV_TARGET_DEVADDR:
186 streams_bm = rc->uwb_dev.streams;
187 break;
188 default:
189 return;
190 }
191
192 clear_bit(rsv->stream, streams_bm);
Stefano Panella5b377172008-12-12 13:00:06 +0000193
194 dev_dbg(dev, "put stream %d\n", rsv->stream);
David Vrabel8cc13a02008-09-17 16:34:09 +0100195}
196
Stefano Panella5b377172008-12-12 13:00:06 +0000197void uwb_rsv_backoff_win_timer(unsigned long arg)
David Vrabel8cc13a02008-09-17 16:34:09 +0100198{
Stefano Panella5b377172008-12-12 13:00:06 +0000199 struct uwb_drp_backoff_win *bow = (struct uwb_drp_backoff_win *)arg;
200 struct uwb_rc *rc = container_of(bow, struct uwb_rc, bow);
201 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100202
Stefano Panella5b377172008-12-12 13:00:06 +0000203 bow->can_reserve_extra_mases = true;
204 if (bow->total_expired <= 4) {
205 bow->total_expired++;
206 } else {
207 /* after 4 backoff window has expired we can exit from
208 * the backoff procedure */
209 bow->total_expired = 0;
210 bow->window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
David Vrabel8cc13a02008-09-17 16:34:09 +0100211 }
Stefano Panella5b377172008-12-12 13:00:06 +0000212 dev_dbg(dev, "backoff_win_timer total_expired=%d, n=%d\n: ", bow->total_expired, bow->n);
213
214 /* try to relocate all the "to be moved" relocations */
215 uwb_rsv_handle_drp_avail_change(rc);
David Vrabel8cc13a02008-09-17 16:34:09 +0100216}
217
Stefano Panella5b377172008-12-12 13:00:06 +0000218void uwb_rsv_backoff_win_increment(struct uwb_rc *rc)
David Vrabel8cc13a02008-09-17 16:34:09 +0100219{
Stefano Panella5b377172008-12-12 13:00:06 +0000220 struct uwb_drp_backoff_win *bow = &rc->bow;
221 struct device *dev = &rc->uwb_dev.dev;
222 unsigned timeout_us;
David Vrabel8cc13a02008-09-17 16:34:09 +0100223
Stefano Panella5b377172008-12-12 13:00:06 +0000224 dev_dbg(dev, "backoff_win_increment: window=%d\n", bow->window);
David Vrabel8cc13a02008-09-17 16:34:09 +0100225
Stefano Panella5b377172008-12-12 13:00:06 +0000226 bow->can_reserve_extra_mases = false;
David Vrabel8cc13a02008-09-17 16:34:09 +0100227
Stefano Panella5b377172008-12-12 13:00:06 +0000228 if((bow->window << 1) == UWB_DRP_BACKOFF_WIN_MAX)
229 return;
David Vrabel8cc13a02008-09-17 16:34:09 +0100230
Stefano Panella5b377172008-12-12 13:00:06 +0000231 bow->window <<= 1;
232 bow->n = random32() & (bow->window - 1);
233 dev_dbg(dev, "new_window=%d, n=%d\n: ", bow->window, bow->n);
David Vrabel8cc13a02008-09-17 16:34:09 +0100234
Stefano Panella5b377172008-12-12 13:00:06 +0000235 /* reset the timer associated variables */
236 timeout_us = bow->n * UWB_SUPERFRAME_LENGTH_US;
237 bow->total_expired = 0;
238 mod_timer(&bow->timer, jiffies + usecs_to_jiffies(timeout_us));
David Vrabel8cc13a02008-09-17 16:34:09 +0100239}
240
241static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
242{
243 int sframes = UWB_MAX_LOST_BEACONS;
244
245 /*
246 * Multicast reservations can become established within 1
247 * super frame and should not be terminated if no response is
248 * received.
249 */
250 if (rsv->is_multicast) {
Stefano Panella5b377172008-12-12 13:00:06 +0000251 if (rsv->state == UWB_RSV_STATE_O_INITIATED
252 || rsv->state == UWB_RSV_STATE_O_MOVE_EXPANDING
253 || rsv->state == UWB_RSV_STATE_O_MOVE_COMBINING
254 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING)
David Vrabel8cc13a02008-09-17 16:34:09 +0100255 sframes = 1;
256 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
257 sframes = 0;
Stefano Panella5b377172008-12-12 13:00:06 +0000258
David Vrabel8cc13a02008-09-17 16:34:09 +0100259 }
260
David Vrabel8cc13a02008-09-17 16:34:09 +0100261 if (sframes > 0) {
262 /*
263 * Add an additional 2 superframes to account for the
264 * time to send the SET DRP IE command.
265 */
266 unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
267 mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
268 } else
269 del_timer(&rsv->timer);
270}
271
272/*
273 * Update a reservations state, and schedule an update of the
274 * transmitted DRP IEs.
275 */
276static void uwb_rsv_state_update(struct uwb_rsv *rsv,
277 enum uwb_rsv_state new_state)
278{
279 rsv->state = new_state;
280 rsv->ie_valid = false;
281
Stefano Panella5b377172008-12-12 13:00:06 +0000282 uwb_rsv_dump("SU", rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100283
284 uwb_rsv_stroke_timer(rsv);
285 uwb_rsv_sched_update(rsv->rc);
286}
287
288static void uwb_rsv_callback(struct uwb_rsv *rsv)
289{
290 if (rsv->callback)
291 rsv->callback(rsv);
292}
293
294void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
295{
Stefano Panella5b377172008-12-12 13:00:06 +0000296 struct uwb_rsv_move *mv = &rsv->mv;
297
David Vrabel8cc13a02008-09-17 16:34:09 +0100298 if (rsv->state == new_state) {
299 switch (rsv->state) {
300 case UWB_RSV_STATE_O_ESTABLISHED:
Stefano Panella5b377172008-12-12 13:00:06 +0000301 case UWB_RSV_STATE_O_MOVE_EXPANDING:
302 case UWB_RSV_STATE_O_MOVE_COMBINING:
303 case UWB_RSV_STATE_O_MOVE_REDUCING:
David Vrabel8cc13a02008-09-17 16:34:09 +0100304 case UWB_RSV_STATE_T_ACCEPTED:
Stefano Panella5b377172008-12-12 13:00:06 +0000305 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
306 case UWB_RSV_STATE_T_RESIZED:
David Vrabel8cc13a02008-09-17 16:34:09 +0100307 case UWB_RSV_STATE_NONE:
308 uwb_rsv_stroke_timer(rsv);
309 break;
310 default:
311 /* Expecting a state transition so leave timer
312 as-is. */
313 break;
314 }
315 return;
316 }
317
Stefano Panella5b377172008-12-12 13:00:06 +0000318 uwb_rsv_dump("SC", rsv);
319
David Vrabel8cc13a02008-09-17 16:34:09 +0100320 switch (new_state) {
321 case UWB_RSV_STATE_NONE:
David Vrabel8cc13a02008-09-17 16:34:09 +0100322 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
323 uwb_rsv_callback(rsv);
324 break;
325 case UWB_RSV_STATE_O_INITIATED:
326 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
327 break;
328 case UWB_RSV_STATE_O_PENDING:
329 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
330 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000331 case UWB_RSV_STATE_O_MODIFIED:
332 /* in the companion there are the MASes to drop */
333 bitmap_andnot(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
334 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MODIFIED);
335 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100336 case UWB_RSV_STATE_O_ESTABLISHED:
Stefano Panella5b377172008-12-12 13:00:06 +0000337 if (rsv->state == UWB_RSV_STATE_O_MODIFIED
338 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING) {
339 uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
340 rsv->needs_release_companion_mas = false;
341 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100342 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
343 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
344 uwb_rsv_callback(rsv);
345 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000346 case UWB_RSV_STATE_O_MOVE_EXPANDING:
347 rsv->needs_release_companion_mas = true;
348 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
349 break;
350 case UWB_RSV_STATE_O_MOVE_COMBINING:
351 rsv->needs_release_companion_mas = false;
352 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
353 bitmap_or(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
354 rsv->mas.safe += mv->companion_mas.safe;
355 rsv->mas.unsafe += mv->companion_mas.unsafe;
356 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
357 break;
358 case UWB_RSV_STATE_O_MOVE_REDUCING:
359 bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
360 rsv->needs_release_companion_mas = true;
361 rsv->mas.safe = mv->final_mas.safe;
362 rsv->mas.unsafe = mv->final_mas.unsafe;
363 bitmap_copy(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
364 bitmap_copy(rsv->mas.unsafe_bm, mv->final_mas.unsafe_bm, UWB_NUM_MAS);
365 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
366 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100367 case UWB_RSV_STATE_T_ACCEPTED:
Stefano Panella5b377172008-12-12 13:00:06 +0000368 case UWB_RSV_STATE_T_RESIZED:
369 rsv->needs_release_companion_mas = false;
David Vrabel8cc13a02008-09-17 16:34:09 +0100370 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
371 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
372 uwb_rsv_callback(rsv);
373 break;
374 case UWB_RSV_STATE_T_DENIED:
375 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
376 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000377 case UWB_RSV_STATE_T_CONFLICT:
378 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_CONFLICT);
379 break;
380 case UWB_RSV_STATE_T_PENDING:
381 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_PENDING);
382 break;
383 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
384 rsv->needs_release_companion_mas = true;
385 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
386 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
387 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100388 default:
389 dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
390 uwb_rsv_state_str(new_state), new_state);
391 }
392}
393
Stefano Panella5b377172008-12-12 13:00:06 +0000394static void uwb_rsv_handle_timeout_work(struct work_struct *work)
395{
396 struct uwb_rsv *rsv = container_of(work, struct uwb_rsv,
397 handle_timeout_work);
398 struct uwb_rc *rc = rsv->rc;
399
400 mutex_lock(&rc->rsvs_mutex);
401
402 uwb_rsv_dump("TO", rsv);
403
404 switch (rsv->state) {
405 case UWB_RSV_STATE_O_INITIATED:
406 if (rsv->is_multicast) {
407 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
408 goto unlock;
409 }
410 break;
411 case UWB_RSV_STATE_O_MOVE_EXPANDING:
412 if (rsv->is_multicast) {
413 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
414 goto unlock;
415 }
416 break;
417 case UWB_RSV_STATE_O_MOVE_COMBINING:
418 if (rsv->is_multicast) {
419 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
420 goto unlock;
421 }
422 break;
423 case UWB_RSV_STATE_O_MOVE_REDUCING:
424 if (rsv->is_multicast) {
425 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
426 goto unlock;
427 }
428 break;
429 case UWB_RSV_STATE_O_ESTABLISHED:
430 if (rsv->is_multicast)
431 goto unlock;
432 break;
433 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
434 /*
435 * The time out could be for the main or of the
436 * companion DRP, assume it's for the companion and
437 * drop that first. A further time out is required to
438 * drop the main.
439 */
440 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
441 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
442 goto unlock;
443 default:
444 break;
445 }
446
447 uwb_rsv_remove(rsv);
448
449unlock:
450 mutex_unlock(&rc->rsvs_mutex);
451}
452
David Vrabel8cc13a02008-09-17 16:34:09 +0100453static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
454{
455 struct uwb_rsv *rsv;
456
457 rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
458 if (!rsv)
459 return NULL;
460
461 INIT_LIST_HEAD(&rsv->rc_node);
462 INIT_LIST_HEAD(&rsv->pal_node);
David Vrabelcae1c112008-10-27 15:22:46 +0000463 kref_init(&rsv->kref);
David Vrabel8cc13a02008-09-17 16:34:09 +0100464 init_timer(&rsv->timer);
465 rsv->timer.function = uwb_rsv_timer;
466 rsv->timer.data = (unsigned long)rsv;
467
468 rsv->rc = rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000469 INIT_WORK(&rsv->handle_timeout_work, uwb_rsv_handle_timeout_work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100470
471 return rsv;
472}
473
David Vrabel8cc13a02008-09-17 16:34:09 +0100474/**
475 * uwb_rsv_create - allocate and initialize a UWB reservation structure
476 * @rc: the radio controller
477 * @cb: callback to use when the reservation completes or terminates
478 * @pal_priv: data private to the PAL to be passed in the callback
479 *
480 * The callback is called when the state of the reservation changes from:
481 *
482 * - pending to accepted
483 * - pending to denined
484 * - accepted to terminated
485 * - pending to terminated
486 */
487struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
488{
489 struct uwb_rsv *rsv;
490
491 rsv = uwb_rsv_alloc(rc);
492 if (!rsv)
493 return NULL;
494
495 rsv->callback = cb;
496 rsv->pal_priv = pal_priv;
497
498 return rsv;
499}
500EXPORT_SYMBOL_GPL(uwb_rsv_create);
501
502void uwb_rsv_remove(struct uwb_rsv *rsv)
503{
Stefano Panella5b377172008-12-12 13:00:06 +0000504 uwb_rsv_dump("RM", rsv);
505
David Vrabel8cc13a02008-09-17 16:34:09 +0100506 if (rsv->state != UWB_RSV_STATE_NONE)
507 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
Stefano Panella5b377172008-12-12 13:00:06 +0000508
509 if (rsv->needs_release_companion_mas)
510 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
511 uwb_drp_avail_release(rsv->rc, &rsv->mas);
512
513 if (uwb_rsv_is_owner(rsv))
514 uwb_rsv_put_stream(rsv);
David Vrabel2226b1c2009-01-06 17:55:32 +0000515
David Vrabelcae1c112008-10-27 15:22:46 +0000516 uwb_dev_put(rsv->owner);
517 if (rsv->target.type == UWB_RSV_TARGET_DEV)
518 uwb_dev_put(rsv->target.dev);
519
520 list_del_init(&rsv->rc_node);
521 uwb_rsv_put(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100522}
523
524/**
525 * uwb_rsv_destroy - free a UWB reservation structure
526 * @rsv: the reservation to free
527 *
David Vrabelcae1c112008-10-27 15:22:46 +0000528 * The reservation must already be terminated.
David Vrabel8cc13a02008-09-17 16:34:09 +0100529 */
530void uwb_rsv_destroy(struct uwb_rsv *rsv)
531{
David Vrabelcae1c112008-10-27 15:22:46 +0000532 uwb_rsv_put(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100533}
534EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
535
536/**
537 * usb_rsv_establish - start a reservation establishment
538 * @rsv: the reservation
539 *
540 * The PAL should fill in @rsv's owner, target, type, max_mas,
Stefano Panella5b377172008-12-12 13:00:06 +0000541 * min_mas, max_interval and is_multicast fields. If the target is a
David Vrabel8cc13a02008-09-17 16:34:09 +0100542 * uwb_dev it must be referenced.
543 *
544 * The reservation's callback will be called when the reservation is
545 * accepted, denied or times out.
546 */
547int uwb_rsv_establish(struct uwb_rsv *rsv)
548{
549 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000550 struct uwb_mas_bm available;
David Vrabel8cc13a02008-09-17 16:34:09 +0100551 int ret;
552
553 mutex_lock(&rc->rsvs_mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100554 ret = uwb_rsv_get_stream(rsv);
555 if (ret)
556 goto out;
557
Stefano Panella5b377172008-12-12 13:00:06 +0000558 rsv->tiebreaker = random32() & 1;
559 /* get available mas bitmap */
560 uwb_drp_available(rc, &available);
561
562 ret = uwb_rsv_find_best_allocation(rsv, &available, &rsv->mas);
563 if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
564 ret = -EBUSY;
565 uwb_rsv_put_stream(rsv);
566 goto out;
567 }
568
569 ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
570 if (ret != 0) {
David Vrabel8cc13a02008-09-17 16:34:09 +0100571 uwb_rsv_put_stream(rsv);
572 goto out;
573 }
574
David Vrabelcae1c112008-10-27 15:22:46 +0000575 uwb_rsv_get(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100576 list_add_tail(&rsv->rc_node, &rc->reservations);
577 rsv->owner = &rc->uwb_dev;
578 uwb_dev_get(rsv->owner);
579 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
580out:
581 mutex_unlock(&rc->rsvs_mutex);
582 return ret;
583}
584EXPORT_SYMBOL_GPL(uwb_rsv_establish);
585
586/**
587 * uwb_rsv_modify - modify an already established reservation
588 * @rsv: the reservation to modify
589 * @max_mas: new maximum MAS to reserve
590 * @min_mas: new minimum MAS to reserve
Stefano Panella5b377172008-12-12 13:00:06 +0000591 * @max_interval: new max_interval to use
David Vrabel8cc13a02008-09-17 16:34:09 +0100592 *
593 * FIXME: implement this once there are PALs that use it.
594 */
Stefano Panella5b377172008-12-12 13:00:06 +0000595int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int max_interval)
David Vrabel8cc13a02008-09-17 16:34:09 +0100596{
597 return -ENOSYS;
598}
599EXPORT_SYMBOL_GPL(uwb_rsv_modify);
600
Stefano Panella5b377172008-12-12 13:00:06 +0000601/*
602 * move an already established reservation (rc->rsvs_mutex must to be
603 * taken when tis function is called)
604 */
605int uwb_rsv_try_move(struct uwb_rsv *rsv, struct uwb_mas_bm *available)
606{
607 struct uwb_rc *rc = rsv->rc;
608 struct uwb_drp_backoff_win *bow = &rc->bow;
609 struct device *dev = &rc->uwb_dev.dev;
610 struct uwb_rsv_move *mv;
611 int ret = 0;
612
613 if (bow->can_reserve_extra_mases == false)
614 return -EBUSY;
615
616 mv = &rsv->mv;
617
618 if (uwb_rsv_find_best_allocation(rsv, available, &mv->final_mas) == UWB_RSV_ALLOC_FOUND) {
619
620 if (!bitmap_equal(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS)) {
621 /* We want to move the reservation */
622 bitmap_andnot(mv->companion_mas.bm, mv->final_mas.bm, rsv->mas.bm, UWB_NUM_MAS);
623 uwb_drp_avail_reserve_pending(rc, &mv->companion_mas);
624 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
625 }
626 } else {
627 dev_dbg(dev, "new allocation not found\n");
628 }
629
630 return ret;
631}
632
633/* It will try to move every reservation in state O_ESTABLISHED giving
634 * to the MAS allocator algorithm an availability that is the real one
635 * plus the allocation already established from the reservation. */
636void uwb_rsv_handle_drp_avail_change(struct uwb_rc *rc)
637{
638 struct uwb_drp_backoff_win *bow = &rc->bow;
639 struct uwb_rsv *rsv;
640 struct uwb_mas_bm mas;
641
642 if (bow->can_reserve_extra_mases == false)
643 return;
644
645 list_for_each_entry(rsv, &rc->reservations, rc_node) {
646 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED ||
647 rsv->state == UWB_RSV_STATE_O_TO_BE_MOVED) {
648 uwb_drp_available(rc, &mas);
649 bitmap_or(mas.bm, mas.bm, rsv->mas.bm, UWB_NUM_MAS);
650 uwb_rsv_try_move(rsv, &mas);
651 }
652 }
653
654}
655
David Vrabel8cc13a02008-09-17 16:34:09 +0100656/**
657 * uwb_rsv_terminate - terminate an established reservation
658 * @rsv: the reservation to terminate
659 *
660 * A reservation is terminated by removing the DRP IE from the beacon,
661 * the other end will consider the reservation to be terminated when
662 * it does not see the DRP IE for at least mMaxLostBeacons.
663 *
664 * If applicable, the reference to the target uwb_dev will be released.
665 */
666void uwb_rsv_terminate(struct uwb_rsv *rsv)
667{
668 struct uwb_rc *rc = rsv->rc;
669
670 mutex_lock(&rc->rsvs_mutex);
671
David Vrabel671e4702008-12-12 13:23:24 +0000672 if (rsv->state != UWB_RSV_STATE_NONE)
673 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
David Vrabel8cc13a02008-09-17 16:34:09 +0100674
675 mutex_unlock(&rc->rsvs_mutex);
676}
677EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
678
679/**
680 * uwb_rsv_accept - accept a new reservation from a peer
681 * @rsv: the reservation
682 * @cb: call back for reservation changes
683 * @pal_priv: data to be passed in the above call back
684 *
685 * Reservation requests from peers are denied unless a PAL accepts it
686 * by calling this function.
David Vrabelcae1c112008-10-27 15:22:46 +0000687 *
688 * The PAL call uwb_rsv_destroy() for all accepted reservations before
689 * calling uwb_pal_unregister().
David Vrabel8cc13a02008-09-17 16:34:09 +0100690 */
691void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
692{
David Vrabelcae1c112008-10-27 15:22:46 +0000693 uwb_rsv_get(rsv);
694
David Vrabel8cc13a02008-09-17 16:34:09 +0100695 rsv->callback = cb;
696 rsv->pal_priv = pal_priv;
697 rsv->state = UWB_RSV_STATE_T_ACCEPTED;
698}
699EXPORT_SYMBOL_GPL(uwb_rsv_accept);
700
701/*
702 * Is a received DRP IE for this reservation?
703 */
704static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
705 struct uwb_ie_drp *drp_ie)
706{
707 struct uwb_dev_addr *rsv_src;
708 int stream;
709
710 stream = uwb_ie_drp_stream_index(drp_ie);
711
712 if (rsv->stream != stream)
713 return false;
714
715 switch (rsv->target.type) {
716 case UWB_RSV_TARGET_DEVADDR:
717 return rsv->stream == stream;
718 case UWB_RSV_TARGET_DEV:
719 if (uwb_ie_drp_owner(drp_ie))
720 rsv_src = &rsv->owner->dev_addr;
721 else
722 rsv_src = &rsv->target.dev->dev_addr;
723 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
724 }
725 return false;
726}
727
728static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
729 struct uwb_dev *src,
730 struct uwb_ie_drp *drp_ie)
731{
732 struct uwb_rsv *rsv;
733 struct uwb_pal *pal;
734 enum uwb_rsv_state state;
735
736 rsv = uwb_rsv_alloc(rc);
737 if (!rsv)
738 return NULL;
739
740 rsv->rc = rc;
741 rsv->owner = src;
742 uwb_dev_get(rsv->owner);
743 rsv->target.type = UWB_RSV_TARGET_DEV;
744 rsv->target.dev = &rc->uwb_dev;
Stefano Panella5b377172008-12-12 13:00:06 +0000745 uwb_dev_get(&rc->uwb_dev);
David Vrabel8cc13a02008-09-17 16:34:09 +0100746 rsv->type = uwb_ie_drp_type(drp_ie);
747 rsv->stream = uwb_ie_drp_stream_index(drp_ie);
David Vrabel8cc13a02008-09-17 16:34:09 +0100748 uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
749
750 /*
751 * See if any PALs are interested in this reservation. If not,
752 * deny the request.
753 */
754 rsv->state = UWB_RSV_STATE_T_DENIED;
David Vrabel6fae35f2008-11-17 15:53:42 +0000755 mutex_lock(&rc->uwb_dev.mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100756 list_for_each_entry(pal, &rc->pals, node) {
757 if (pal->new_rsv)
David Vrabele17be2b2008-11-17 15:24:14 +0000758 pal->new_rsv(pal, rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100759 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
760 break;
761 }
David Vrabel6fae35f2008-11-17 15:53:42 +0000762 mutex_unlock(&rc->uwb_dev.mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100763
764 list_add_tail(&rsv->rc_node, &rc->reservations);
765 state = rsv->state;
766 rsv->state = UWB_RSV_STATE_NONE;
Stefano Panella5b377172008-12-12 13:00:06 +0000767
768 /* FIXME: do something sensible here */
769 if (state == UWB_RSV_STATE_T_ACCEPTED
770 && uwb_drp_avail_reserve_pending(rc, &rsv->mas) == -EBUSY) {
771 /* FIXME: do something sensible here */
772 } else {
773 uwb_rsv_set_state(rsv, state);
774 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100775
776 return rsv;
777}
778
779/**
Stefano Panella5b377172008-12-12 13:00:06 +0000780 * uwb_rsv_get_usable_mas - get the bitmap of the usable MAS of a reservations
781 * @rsv: the reservation.
782 * @mas: returns the available MAS.
783 *
784 * The usable MAS of a reservation may be less than the negotiated MAS
785 * if alien BPs are present.
786 */
787void uwb_rsv_get_usable_mas(struct uwb_rsv *rsv, struct uwb_mas_bm *mas)
788{
789 bitmap_zero(mas->bm, UWB_NUM_MAS);
790 bitmap_andnot(mas->bm, rsv->mas.bm, rsv->rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
791}
792EXPORT_SYMBOL_GPL(uwb_rsv_get_usable_mas);
793
794/**
David Vrabel8cc13a02008-09-17 16:34:09 +0100795 * uwb_rsv_find - find a reservation for a received DRP IE.
796 * @rc: the radio controller
797 * @src: source of the DRP IE
798 * @drp_ie: the DRP IE
799 *
800 * If the reservation cannot be found and the DRP IE is from a peer
801 * attempting to establish a new reservation, create a new reservation
802 * and add it to the list.
803 */
804struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
805 struct uwb_ie_drp *drp_ie)
806{
807 struct uwb_rsv *rsv;
808
809 list_for_each_entry(rsv, &rc->reservations, rc_node) {
810 if (uwb_rsv_match(rsv, src, drp_ie))
811 return rsv;
812 }
813
814 if (uwb_ie_drp_owner(drp_ie))
815 return uwb_rsv_new_target(rc, src, drp_ie);
816
817 return NULL;
818}
819
820/*
821 * Go through all the reservations and check for timeouts and (if
822 * necessary) update their DRP IEs.
823 *
824 * FIXME: look at building the SET_DRP_IE command here rather than
825 * having to rescan the list in uwb_rc_send_all_drp_ie().
826 */
827static bool uwb_rsv_update_all(struct uwb_rc *rc)
828{
829 struct uwb_rsv *rsv, *t;
830 bool ie_updated = false;
831
832 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
David Vrabel8cc13a02008-09-17 16:34:09 +0100833 if (!rsv->ie_valid) {
834 uwb_drp_ie_update(rsv);
835 ie_updated = true;
836 }
837 }
838
839 return ie_updated;
840}
841
Stefano Panella5b377172008-12-12 13:00:06 +0000842void uwb_rsv_queue_update(struct uwb_rc *rc)
843{
844 unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
845
846 queue_delayed_work(rc->rsv_workq, &rc->rsv_update_work, usecs_to_jiffies(delay_us));
847}
848
849/**
850 * uwb_rsv_sched_update - schedule an update of the DRP IEs
851 * @rc: the radio controller.
852 *
853 * To improve performance and ensure correctness with [ECMA-368] the
854 * number of SET-DRP-IE commands that are done are limited.
855 *
856 * DRP IEs update come from two sources: DRP events from the hardware
857 * which all occur at the beginning of the superframe ('syncronous'
858 * events) and reservation establishment/termination requests from
859 * PALs or timers ('asynchronous' events).
860 *
861 * A delayed work ensures that all the synchronous events result in
862 * one SET-DRP-IE command.
863 *
864 * Additional logic (the set_drp_ie_pending and rsv_updated_postponed
865 * flags) will prevent an asynchrous event starting a SET-DRP-IE
866 * command if one is currently awaiting a response.
867 *
868 * FIXME: this does leave a window where an asynchrous event can delay
869 * the SET-DRP-IE for a synchronous event by one superframe.
870 */
David Vrabel8cc13a02008-09-17 16:34:09 +0100871void uwb_rsv_sched_update(struct uwb_rc *rc)
872{
David Vrabel8f5140a2009-01-23 12:57:20 +0000873 spin_lock_bh(&rc->rsvs_lock);
Stefano Panella5b377172008-12-12 13:00:06 +0000874 if (!delayed_work_pending(&rc->rsv_update_work)) {
875 if (rc->set_drp_ie_pending > 0) {
876 rc->set_drp_ie_pending++;
877 goto unlock;
878 }
879 uwb_rsv_queue_update(rc);
880 }
881unlock:
David Vrabel8f5140a2009-01-23 12:57:20 +0000882 spin_unlock_bh(&rc->rsvs_lock);
David Vrabel8cc13a02008-09-17 16:34:09 +0100883}
884
885/*
886 * Update DRP IEs and, if necessary, the DRP Availability IE and send
887 * the updated IEs to the radio controller.
888 */
889static void uwb_rsv_update_work(struct work_struct *work)
890{
Stefano Panella5b377172008-12-12 13:00:06 +0000891 struct uwb_rc *rc = container_of(work, struct uwb_rc,
892 rsv_update_work.work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100893 bool ie_updated;
894
895 mutex_lock(&rc->rsvs_mutex);
896
897 ie_updated = uwb_rsv_update_all(rc);
898
899 if (!rc->drp_avail.ie_valid) {
900 uwb_drp_avail_ie_update(rc);
901 ie_updated = true;
902 }
903
Stefano Panella5b377172008-12-12 13:00:06 +0000904 if (ie_updated && (rc->set_drp_ie_pending == 0))
David Vrabel8cc13a02008-09-17 16:34:09 +0100905 uwb_rc_send_all_drp_ie(rc);
906
907 mutex_unlock(&rc->rsvs_mutex);
908}
909
Stefano Panella5b377172008-12-12 13:00:06 +0000910static void uwb_rsv_alien_bp_work(struct work_struct *work)
911{
912 struct uwb_rc *rc = container_of(work, struct uwb_rc,
913 rsv_alien_bp_work.work);
914 struct uwb_rsv *rsv;
915
916 mutex_lock(&rc->rsvs_mutex);
917
918 list_for_each_entry(rsv, &rc->reservations, rc_node) {
919 if (rsv->type != UWB_DRP_TYPE_ALIEN_BP) {
920 rsv->callback(rsv);
921 }
922 }
923
924 mutex_unlock(&rc->rsvs_mutex);
925}
926
David Vrabel8cc13a02008-09-17 16:34:09 +0100927static void uwb_rsv_timer(unsigned long arg)
928{
929 struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
930
Stefano Panella5b377172008-12-12 13:00:06 +0000931 queue_work(rsv->rc->rsv_workq, &rsv->handle_timeout_work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100932}
933
David Vrabel307ba6d2008-11-07 17:37:33 +0000934/**
935 * uwb_rsv_remove_all - remove all reservations
936 * @rc: the radio controller
937 *
938 * A DRP IE update is not done.
939 */
940void uwb_rsv_remove_all(struct uwb_rc *rc)
941{
942 struct uwb_rsv *rsv, *t;
943
944 mutex_lock(&rc->rsvs_mutex);
945 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
David Vrabel2226b1c2009-01-06 17:55:32 +0000946 if (rsv->state != UWB_RSV_STATE_NONE)
947 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
948 del_timer_sync(&rsv->timer);
David Vrabel307ba6d2008-11-07 17:37:33 +0000949 }
Stefano Panella5b377172008-12-12 13:00:06 +0000950 /* Cancel any postponed update. */
951 rc->set_drp_ie_pending = 0;
David Vrabel307ba6d2008-11-07 17:37:33 +0000952 mutex_unlock(&rc->rsvs_mutex);
953
Stefano Panella5b377172008-12-12 13:00:06 +0000954 cancel_delayed_work_sync(&rc->rsv_update_work);
David Vrabel2226b1c2009-01-06 17:55:32 +0000955 flush_workqueue(rc->rsv_workq);
956
957 mutex_lock(&rc->rsvs_mutex);
958 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
959 uwb_rsv_remove(rsv);
960 }
961 mutex_unlock(&rc->rsvs_mutex);
David Vrabel307ba6d2008-11-07 17:37:33 +0000962}
963
David Vrabel8cc13a02008-09-17 16:34:09 +0100964void uwb_rsv_init(struct uwb_rc *rc)
965{
966 INIT_LIST_HEAD(&rc->reservations);
Stefano Panella5b377172008-12-12 13:00:06 +0000967 INIT_LIST_HEAD(&rc->cnflt_alien_list);
David Vrabel8cc13a02008-09-17 16:34:09 +0100968 mutex_init(&rc->rsvs_mutex);
Stefano Panella5b377172008-12-12 13:00:06 +0000969 spin_lock_init(&rc->rsvs_lock);
970 INIT_DELAYED_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
971 INIT_DELAYED_WORK(&rc->rsv_alien_bp_work, uwb_rsv_alien_bp_work);
972 rc->bow.can_reserve_extra_mases = true;
973 rc->bow.total_expired = 0;
974 rc->bow.window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
975 init_timer(&rc->bow.timer);
976 rc->bow.timer.function = uwb_rsv_backoff_win_timer;
977 rc->bow.timer.data = (unsigned long)&rc->bow;
David Vrabel8cc13a02008-09-17 16:34:09 +0100978
979 bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
980}
981
982int uwb_rsv_setup(struct uwb_rc *rc)
983{
984 char name[16];
985
986 snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
987 rc->rsv_workq = create_singlethread_workqueue(name);
988 if (rc->rsv_workq == NULL)
989 return -ENOMEM;
990
991 return 0;
992}
993
994void uwb_rsv_cleanup(struct uwb_rc *rc)
995{
David Vrabel307ba6d2008-11-07 17:37:33 +0000996 uwb_rsv_remove_all(rc);
David Vrabel8cc13a02008-09-17 16:34:09 +0100997 destroy_workqueue(rc->rsv_workq);
998}