blob: 536ad42b0a4b1d7ed0091e4e943a19abf9d0980d [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Stefano Panella5b377172008-12-12 13:00:06 +000021#include <linux/random.h>
Paul Gortmaker475c0a62011-07-10 13:18:02 -040022#include <linux/export.h>
David Vrabel8cc13a02008-09-17 16:34:09 +010023
24#include "uwb-internal.h"
25
26static void uwb_rsv_timer(unsigned long arg);
27
28static const char *rsv_states[] = {
Stefano Panella5b377172008-12-12 13:00:06 +000029 [UWB_RSV_STATE_NONE] = "none ",
30 [UWB_RSV_STATE_O_INITIATED] = "o initiated ",
31 [UWB_RSV_STATE_O_PENDING] = "o pending ",
32 [UWB_RSV_STATE_O_MODIFIED] = "o modified ",
33 [UWB_RSV_STATE_O_ESTABLISHED] = "o established ",
34 [UWB_RSV_STATE_O_TO_BE_MOVED] = "o to be moved ",
35 [UWB_RSV_STATE_O_MOVE_EXPANDING] = "o move expanding",
36 [UWB_RSV_STATE_O_MOVE_COMBINING] = "o move combining",
37 [UWB_RSV_STATE_O_MOVE_REDUCING] = "o move reducing ",
38 [UWB_RSV_STATE_T_ACCEPTED] = "t accepted ",
39 [UWB_RSV_STATE_T_CONFLICT] = "t conflict ",
40 [UWB_RSV_STATE_T_PENDING] = "t pending ",
41 [UWB_RSV_STATE_T_DENIED] = "t denied ",
42 [UWB_RSV_STATE_T_RESIZED] = "t resized ",
43 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = "t expanding acc ",
44 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = "t expanding conf",
45 [UWB_RSV_STATE_T_EXPANDING_PENDING] = "t expanding pend",
46 [UWB_RSV_STATE_T_EXPANDING_DENIED] = "t expanding den ",
David Vrabel8cc13a02008-09-17 16:34:09 +010047};
48
49static const char *rsv_types[] = {
50 [UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
51 [UWB_DRP_TYPE_HARD] = "hard",
52 [UWB_DRP_TYPE_SOFT] = "soft",
53 [UWB_DRP_TYPE_PRIVATE] = "private",
54 [UWB_DRP_TYPE_PCA] = "pca",
55};
56
Stefano Panella5b377172008-12-12 13:00:06 +000057bool uwb_rsv_has_two_drp_ies(struct uwb_rsv *rsv)
58{
59 static const bool has_two_drp_ies[] = {
60 [UWB_RSV_STATE_O_INITIATED] = false,
61 [UWB_RSV_STATE_O_PENDING] = false,
62 [UWB_RSV_STATE_O_MODIFIED] = false,
63 [UWB_RSV_STATE_O_ESTABLISHED] = false,
64 [UWB_RSV_STATE_O_TO_BE_MOVED] = false,
65 [UWB_RSV_STATE_O_MOVE_COMBINING] = false,
66 [UWB_RSV_STATE_O_MOVE_REDUCING] = false,
67 [UWB_RSV_STATE_O_MOVE_EXPANDING] = true,
68 [UWB_RSV_STATE_T_ACCEPTED] = false,
69 [UWB_RSV_STATE_T_CONFLICT] = false,
70 [UWB_RSV_STATE_T_PENDING] = false,
71 [UWB_RSV_STATE_T_DENIED] = false,
72 [UWB_RSV_STATE_T_RESIZED] = false,
73 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = true,
74 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = true,
75 [UWB_RSV_STATE_T_EXPANDING_PENDING] = true,
76 [UWB_RSV_STATE_T_EXPANDING_DENIED] = true,
77 };
78
79 return has_two_drp_ies[rsv->state];
80}
81
David Vrabel8cc13a02008-09-17 16:34:09 +010082/**
83 * uwb_rsv_state_str - return a string for a reservation state
84 * @state: the reservation state.
85 */
86const char *uwb_rsv_state_str(enum uwb_rsv_state state)
87{
88 if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
89 return "unknown";
90 return rsv_states[state];
91}
92EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
93
94/**
95 * uwb_rsv_type_str - return a string for a reservation type
96 * @type: the reservation type
97 */
98const char *uwb_rsv_type_str(enum uwb_drp_type type)
99{
100 if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
101 return "invalid";
102 return rsv_types[type];
103}
104EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
105
Stefano Panella5b377172008-12-12 13:00:06 +0000106void uwb_rsv_dump(char *text, struct uwb_rsv *rsv)
David Vrabel8cc13a02008-09-17 16:34:09 +0100107{
108 struct device *dev = &rsv->rc->uwb_dev.dev;
109 struct uwb_dev_addr devaddr;
110 char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
111
112 uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
113 if (rsv->target.type == UWB_RSV_TARGET_DEV)
114 devaddr = rsv->target.dev->dev_addr;
115 else
116 devaddr = rsv->target.devaddr;
117 uwb_dev_addr_print(target, sizeof(target), &devaddr);
118
David Vrabel2226b1c2009-01-06 17:55:32 +0000119 dev_dbg(dev, "rsv %s %s -> %s: %s\n",
120 text, owner, target, uwb_rsv_state_str(rsv->state));
David Vrabel8cc13a02008-09-17 16:34:09 +0100121}
122
David Vrabelcae1c112008-10-27 15:22:46 +0000123static void uwb_rsv_release(struct kref *kref)
124{
125 struct uwb_rsv *rsv = container_of(kref, struct uwb_rsv, kref);
126
127 kfree(rsv);
128}
129
Stefano Panella5b377172008-12-12 13:00:06 +0000130void uwb_rsv_get(struct uwb_rsv *rsv)
David Vrabelcae1c112008-10-27 15:22:46 +0000131{
132 kref_get(&rsv->kref);
133}
134
Stefano Panella5b377172008-12-12 13:00:06 +0000135void uwb_rsv_put(struct uwb_rsv *rsv)
David Vrabelcae1c112008-10-27 15:22:46 +0000136{
137 kref_put(&rsv->kref, uwb_rsv_release);
138}
139
David Vrabel8cc13a02008-09-17 16:34:09 +0100140/*
141 * Get a free stream index for a reservation.
142 *
143 * If the target is a DevAddr (e.g., a WUSB cluster reservation) then
144 * the stream is allocated from a pool of per-RC stream indexes,
145 * otherwise a unique stream index for the target is selected.
146 */
147static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
148{
149 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000150 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100151 unsigned long *streams_bm;
152 int stream;
153
154 switch (rsv->target.type) {
155 case UWB_RSV_TARGET_DEV:
156 streams_bm = rsv->target.dev->streams;
157 break;
158 case UWB_RSV_TARGET_DEVADDR:
159 streams_bm = rc->uwb_dev.streams;
160 break;
161 default:
162 return -EINVAL;
163 }
164
165 stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500166 if (stream >= UWB_NUM_STREAMS) {
167 dev_err(dev, "%s: no available stream found\n", __func__);
David Vrabel8cc13a02008-09-17 16:34:09 +0100168 return -EBUSY;
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500169 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100170
171 rsv->stream = stream;
172 set_bit(stream, streams_bm);
173
Stefano Panella5b377172008-12-12 13:00:06 +0000174 dev_dbg(dev, "get stream %d\n", rsv->stream);
175
David Vrabel8cc13a02008-09-17 16:34:09 +0100176 return 0;
177}
178
179static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
180{
181 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000182 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100183 unsigned long *streams_bm;
184
185 switch (rsv->target.type) {
186 case UWB_RSV_TARGET_DEV:
187 streams_bm = rsv->target.dev->streams;
188 break;
189 case UWB_RSV_TARGET_DEVADDR:
190 streams_bm = rc->uwb_dev.streams;
191 break;
192 default:
193 return;
194 }
195
196 clear_bit(rsv->stream, streams_bm);
Stefano Panella5b377172008-12-12 13:00:06 +0000197
198 dev_dbg(dev, "put stream %d\n", rsv->stream);
David Vrabel8cc13a02008-09-17 16:34:09 +0100199}
200
Stefano Panella5b377172008-12-12 13:00:06 +0000201void uwb_rsv_backoff_win_timer(unsigned long arg)
David Vrabel8cc13a02008-09-17 16:34:09 +0100202{
Stefano Panella5b377172008-12-12 13:00:06 +0000203 struct uwb_drp_backoff_win *bow = (struct uwb_drp_backoff_win *)arg;
204 struct uwb_rc *rc = container_of(bow, struct uwb_rc, bow);
205 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100206
Stefano Panella5b377172008-12-12 13:00:06 +0000207 bow->can_reserve_extra_mases = true;
208 if (bow->total_expired <= 4) {
209 bow->total_expired++;
210 } else {
211 /* after 4 backoff window has expired we can exit from
212 * the backoff procedure */
213 bow->total_expired = 0;
214 bow->window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
David Vrabel8cc13a02008-09-17 16:34:09 +0100215 }
Geert Uytterhoevend9c3ae22014-10-23 11:52:57 +0200216 dev_dbg(dev, "backoff_win_timer total_expired=%d, n=%d\n", bow->total_expired, bow->n);
Stefano Panella5b377172008-12-12 13:00:06 +0000217
218 /* try to relocate all the "to be moved" relocations */
219 uwb_rsv_handle_drp_avail_change(rc);
David Vrabel8cc13a02008-09-17 16:34:09 +0100220}
221
Stefano Panella5b377172008-12-12 13:00:06 +0000222void uwb_rsv_backoff_win_increment(struct uwb_rc *rc)
David Vrabel8cc13a02008-09-17 16:34:09 +0100223{
Stefano Panella5b377172008-12-12 13:00:06 +0000224 struct uwb_drp_backoff_win *bow = &rc->bow;
225 struct device *dev = &rc->uwb_dev.dev;
226 unsigned timeout_us;
David Vrabel8cc13a02008-09-17 16:34:09 +0100227
Stefano Panella5b377172008-12-12 13:00:06 +0000228 dev_dbg(dev, "backoff_win_increment: window=%d\n", bow->window);
David Vrabel8cc13a02008-09-17 16:34:09 +0100229
Stefano Panella5b377172008-12-12 13:00:06 +0000230 bow->can_reserve_extra_mases = false;
David Vrabel8cc13a02008-09-17 16:34:09 +0100231
Stefano Panella5b377172008-12-12 13:00:06 +0000232 if((bow->window << 1) == UWB_DRP_BACKOFF_WIN_MAX)
233 return;
David Vrabel8cc13a02008-09-17 16:34:09 +0100234
Stefano Panella5b377172008-12-12 13:00:06 +0000235 bow->window <<= 1;
Akinobu Mita78782022013-04-29 16:21:34 -0700236 bow->n = prandom_u32() & (bow->window - 1);
Geert Uytterhoevend9c3ae22014-10-23 11:52:57 +0200237 dev_dbg(dev, "new_window=%d, n=%d\n", bow->window, bow->n);
David Vrabel8cc13a02008-09-17 16:34:09 +0100238
Stefano Panella5b377172008-12-12 13:00:06 +0000239 /* reset the timer associated variables */
240 timeout_us = bow->n * UWB_SUPERFRAME_LENGTH_US;
241 bow->total_expired = 0;
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600242 mod_timer(&bow->timer, jiffies + usecs_to_jiffies(timeout_us));
David Vrabel8cc13a02008-09-17 16:34:09 +0100243}
244
245static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
246{
247 int sframes = UWB_MAX_LOST_BEACONS;
248
249 /*
250 * Multicast reservations can become established within 1
251 * super frame and should not be terminated if no response is
252 * received.
253 */
Thomas Pugliese90ec00d2014-04-25 10:30:32 -0500254 if (rsv->state == UWB_RSV_STATE_NONE) {
255 sframes = 0;
256 } else if (rsv->is_multicast) {
Stefano Panella5b377172008-12-12 13:00:06 +0000257 if (rsv->state == UWB_RSV_STATE_O_INITIATED
258 || rsv->state == UWB_RSV_STATE_O_MOVE_EXPANDING
259 || rsv->state == UWB_RSV_STATE_O_MOVE_COMBINING
260 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING)
David Vrabel8cc13a02008-09-17 16:34:09 +0100261 sframes = 1;
262 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
263 sframes = 0;
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600264
David Vrabel8cc13a02008-09-17 16:34:09 +0100265 }
266
David Vrabel8cc13a02008-09-17 16:34:09 +0100267 if (sframes > 0) {
268 /*
269 * Add an additional 2 superframes to account for the
270 * time to send the SET DRP IE command.
271 */
272 unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
273 mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
274 } else
275 del_timer(&rsv->timer);
276}
277
278/*
279 * Update a reservations state, and schedule an update of the
280 * transmitted DRP IEs.
281 */
282static void uwb_rsv_state_update(struct uwb_rsv *rsv,
283 enum uwb_rsv_state new_state)
284{
285 rsv->state = new_state;
286 rsv->ie_valid = false;
287
Stefano Panella5b377172008-12-12 13:00:06 +0000288 uwb_rsv_dump("SU", rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100289
290 uwb_rsv_stroke_timer(rsv);
291 uwb_rsv_sched_update(rsv->rc);
292}
293
294static void uwb_rsv_callback(struct uwb_rsv *rsv)
295{
296 if (rsv->callback)
297 rsv->callback(rsv);
298}
299
300void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
301{
Stefano Panella5b377172008-12-12 13:00:06 +0000302 struct uwb_rsv_move *mv = &rsv->mv;
303
David Vrabel8cc13a02008-09-17 16:34:09 +0100304 if (rsv->state == new_state) {
305 switch (rsv->state) {
306 case UWB_RSV_STATE_O_ESTABLISHED:
Stefano Panella5b377172008-12-12 13:00:06 +0000307 case UWB_RSV_STATE_O_MOVE_EXPANDING:
308 case UWB_RSV_STATE_O_MOVE_COMBINING:
309 case UWB_RSV_STATE_O_MOVE_REDUCING:
David Vrabel8cc13a02008-09-17 16:34:09 +0100310 case UWB_RSV_STATE_T_ACCEPTED:
Stefano Panella5b377172008-12-12 13:00:06 +0000311 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
312 case UWB_RSV_STATE_T_RESIZED:
David Vrabel8cc13a02008-09-17 16:34:09 +0100313 case UWB_RSV_STATE_NONE:
314 uwb_rsv_stroke_timer(rsv);
315 break;
316 default:
317 /* Expecting a state transition so leave timer
318 as-is. */
319 break;
320 }
321 return;
322 }
323
Stefano Panella5b377172008-12-12 13:00:06 +0000324 uwb_rsv_dump("SC", rsv);
325
David Vrabel8cc13a02008-09-17 16:34:09 +0100326 switch (new_state) {
327 case UWB_RSV_STATE_NONE:
David Vrabel8cc13a02008-09-17 16:34:09 +0100328 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
Thomas Pugliese90ec00d2014-04-25 10:30:32 -0500329 uwb_rsv_remove(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100330 uwb_rsv_callback(rsv);
331 break;
332 case UWB_RSV_STATE_O_INITIATED:
333 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
334 break;
335 case UWB_RSV_STATE_O_PENDING:
336 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
337 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000338 case UWB_RSV_STATE_O_MODIFIED:
339 /* in the companion there are the MASes to drop */
340 bitmap_andnot(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
341 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MODIFIED);
342 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100343 case UWB_RSV_STATE_O_ESTABLISHED:
Stefano Panella5b377172008-12-12 13:00:06 +0000344 if (rsv->state == UWB_RSV_STATE_O_MODIFIED
345 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING) {
346 uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
347 rsv->needs_release_companion_mas = false;
348 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100349 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
350 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
351 uwb_rsv_callback(rsv);
352 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000353 case UWB_RSV_STATE_O_MOVE_EXPANDING:
354 rsv->needs_release_companion_mas = true;
355 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
356 break;
357 case UWB_RSV_STATE_O_MOVE_COMBINING:
358 rsv->needs_release_companion_mas = false;
359 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
360 bitmap_or(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
361 rsv->mas.safe += mv->companion_mas.safe;
362 rsv->mas.unsafe += mv->companion_mas.unsafe;
363 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
364 break;
365 case UWB_RSV_STATE_O_MOVE_REDUCING:
366 bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
367 rsv->needs_release_companion_mas = true;
368 rsv->mas.safe = mv->final_mas.safe;
369 rsv->mas.unsafe = mv->final_mas.unsafe;
370 bitmap_copy(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
371 bitmap_copy(rsv->mas.unsafe_bm, mv->final_mas.unsafe_bm, UWB_NUM_MAS);
372 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
373 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100374 case UWB_RSV_STATE_T_ACCEPTED:
Stefano Panella5b377172008-12-12 13:00:06 +0000375 case UWB_RSV_STATE_T_RESIZED:
376 rsv->needs_release_companion_mas = false;
David Vrabel8cc13a02008-09-17 16:34:09 +0100377 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
378 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
379 uwb_rsv_callback(rsv);
380 break;
381 case UWB_RSV_STATE_T_DENIED:
382 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
383 break;
Stefano Panella5b377172008-12-12 13:00:06 +0000384 case UWB_RSV_STATE_T_CONFLICT:
385 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_CONFLICT);
386 break;
387 case UWB_RSV_STATE_T_PENDING:
388 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_PENDING);
389 break;
390 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
391 rsv->needs_release_companion_mas = true;
392 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
393 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
394 break;
David Vrabel8cc13a02008-09-17 16:34:09 +0100395 default:
396 dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
397 uwb_rsv_state_str(new_state), new_state);
398 }
399}
400
Stefano Panella5b377172008-12-12 13:00:06 +0000401static void uwb_rsv_handle_timeout_work(struct work_struct *work)
402{
403 struct uwb_rsv *rsv = container_of(work, struct uwb_rsv,
404 handle_timeout_work);
405 struct uwb_rc *rc = rsv->rc;
406
407 mutex_lock(&rc->rsvs_mutex);
408
409 uwb_rsv_dump("TO", rsv);
410
411 switch (rsv->state) {
412 case UWB_RSV_STATE_O_INITIATED:
413 if (rsv->is_multicast) {
414 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
415 goto unlock;
416 }
417 break;
418 case UWB_RSV_STATE_O_MOVE_EXPANDING:
419 if (rsv->is_multicast) {
420 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
421 goto unlock;
422 }
423 break;
424 case UWB_RSV_STATE_O_MOVE_COMBINING:
425 if (rsv->is_multicast) {
426 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
427 goto unlock;
428 }
429 break;
430 case UWB_RSV_STATE_O_MOVE_REDUCING:
431 if (rsv->is_multicast) {
432 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
433 goto unlock;
434 }
435 break;
436 case UWB_RSV_STATE_O_ESTABLISHED:
437 if (rsv->is_multicast)
438 goto unlock;
439 break;
440 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
441 /*
442 * The time out could be for the main or of the
443 * companion DRP, assume it's for the companion and
444 * drop that first. A further time out is required to
445 * drop the main.
446 */
447 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
448 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
449 goto unlock;
Thomas Pugliese90ec00d2014-04-25 10:30:32 -0500450 case UWB_RSV_STATE_NONE:
451 goto unlock;
Stefano Panella5b377172008-12-12 13:00:06 +0000452 default:
453 break;
454 }
455
456 uwb_rsv_remove(rsv);
457
458unlock:
459 mutex_unlock(&rc->rsvs_mutex);
460}
461
David Vrabel8cc13a02008-09-17 16:34:09 +0100462static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
463{
464 struct uwb_rsv *rsv;
465
466 rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
467 if (!rsv)
468 return NULL;
469
470 INIT_LIST_HEAD(&rsv->rc_node);
471 INIT_LIST_HEAD(&rsv->pal_node);
David Vrabelcae1c112008-10-27 15:22:46 +0000472 kref_init(&rsv->kref);
David Vrabel8cc13a02008-09-17 16:34:09 +0100473 init_timer(&rsv->timer);
474 rsv->timer.function = uwb_rsv_timer;
475 rsv->timer.data = (unsigned long)rsv;
476
477 rsv->rc = rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000478 INIT_WORK(&rsv->handle_timeout_work, uwb_rsv_handle_timeout_work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100479
480 return rsv;
481}
482
David Vrabel8cc13a02008-09-17 16:34:09 +0100483/**
484 * uwb_rsv_create - allocate and initialize a UWB reservation structure
485 * @rc: the radio controller
486 * @cb: callback to use when the reservation completes or terminates
487 * @pal_priv: data private to the PAL to be passed in the callback
488 *
489 * The callback is called when the state of the reservation changes from:
490 *
491 * - pending to accepted
492 * - pending to denined
493 * - accepted to terminated
494 * - pending to terminated
495 */
496struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
497{
498 struct uwb_rsv *rsv;
499
500 rsv = uwb_rsv_alloc(rc);
501 if (!rsv)
502 return NULL;
503
504 rsv->callback = cb;
505 rsv->pal_priv = pal_priv;
506
507 return rsv;
508}
509EXPORT_SYMBOL_GPL(uwb_rsv_create);
510
511void uwb_rsv_remove(struct uwb_rsv *rsv)
512{
Stefano Panella5b377172008-12-12 13:00:06 +0000513 uwb_rsv_dump("RM", rsv);
514
David Vrabel8cc13a02008-09-17 16:34:09 +0100515 if (rsv->state != UWB_RSV_STATE_NONE)
516 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
Stefano Panella5b377172008-12-12 13:00:06 +0000517
518 if (rsv->needs_release_companion_mas)
519 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
520 uwb_drp_avail_release(rsv->rc, &rsv->mas);
521
522 if (uwb_rsv_is_owner(rsv))
523 uwb_rsv_put_stream(rsv);
David Vrabel2226b1c2009-01-06 17:55:32 +0000524
David Vrabelcae1c112008-10-27 15:22:46 +0000525 uwb_dev_put(rsv->owner);
526 if (rsv->target.type == UWB_RSV_TARGET_DEV)
527 uwb_dev_put(rsv->target.dev);
528
529 list_del_init(&rsv->rc_node);
530 uwb_rsv_put(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100531}
532
533/**
534 * uwb_rsv_destroy - free a UWB reservation structure
535 * @rsv: the reservation to free
536 *
David Vrabelcae1c112008-10-27 15:22:46 +0000537 * The reservation must already be terminated.
David Vrabel8cc13a02008-09-17 16:34:09 +0100538 */
539void uwb_rsv_destroy(struct uwb_rsv *rsv)
540{
David Vrabelcae1c112008-10-27 15:22:46 +0000541 uwb_rsv_put(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100542}
543EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
544
545/**
546 * usb_rsv_establish - start a reservation establishment
547 * @rsv: the reservation
548 *
549 * The PAL should fill in @rsv's owner, target, type, max_mas,
Stefano Panella5b377172008-12-12 13:00:06 +0000550 * min_mas, max_interval and is_multicast fields. If the target is a
David Vrabel8cc13a02008-09-17 16:34:09 +0100551 * uwb_dev it must be referenced.
552 *
553 * The reservation's callback will be called when the reservation is
554 * accepted, denied or times out.
555 */
556int uwb_rsv_establish(struct uwb_rsv *rsv)
557{
558 struct uwb_rc *rc = rsv->rc;
Stefano Panella5b377172008-12-12 13:00:06 +0000559 struct uwb_mas_bm available;
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500560 struct device *dev = &rc->uwb_dev.dev;
David Vrabel8cc13a02008-09-17 16:34:09 +0100561 int ret;
562
563 mutex_lock(&rc->rsvs_mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100564 ret = uwb_rsv_get_stream(rsv);
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500565 if (ret) {
566 dev_err(dev, "%s: uwb_rsv_get_stream failed: %d\n",
567 __func__, ret);
David Vrabel8cc13a02008-09-17 16:34:09 +0100568 goto out;
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500569 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100570
Akinobu Mita78782022013-04-29 16:21:34 -0700571 rsv->tiebreaker = prandom_u32() & 1;
Stefano Panella5b377172008-12-12 13:00:06 +0000572 /* get available mas bitmap */
573 uwb_drp_available(rc, &available);
574
575 ret = uwb_rsv_find_best_allocation(rsv, &available, &rsv->mas);
576 if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
577 ret = -EBUSY;
578 uwb_rsv_put_stream(rsv);
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500579 dev_err(dev, "%s: uwb_rsv_find_best_allocation failed: %d\n",
580 __func__, ret);
Stefano Panella5b377172008-12-12 13:00:06 +0000581 goto out;
582 }
583
584 ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
585 if (ret != 0) {
David Vrabel8cc13a02008-09-17 16:34:09 +0100586 uwb_rsv_put_stream(rsv);
Thomas Pugliese7b360ee2014-04-25 10:30:33 -0500587 dev_err(dev, "%s: uwb_drp_avail_reserve_pending failed: %d\n",
588 __func__, ret);
David Vrabel8cc13a02008-09-17 16:34:09 +0100589 goto out;
590 }
591
David Vrabelcae1c112008-10-27 15:22:46 +0000592 uwb_rsv_get(rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100593 list_add_tail(&rsv->rc_node, &rc->reservations);
594 rsv->owner = &rc->uwb_dev;
595 uwb_dev_get(rsv->owner);
596 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
597out:
598 mutex_unlock(&rc->rsvs_mutex);
599 return ret;
600}
601EXPORT_SYMBOL_GPL(uwb_rsv_establish);
602
603/**
604 * uwb_rsv_modify - modify an already established reservation
605 * @rsv: the reservation to modify
606 * @max_mas: new maximum MAS to reserve
607 * @min_mas: new minimum MAS to reserve
Stefano Panella5b377172008-12-12 13:00:06 +0000608 * @max_interval: new max_interval to use
David Vrabel8cc13a02008-09-17 16:34:09 +0100609 *
610 * FIXME: implement this once there are PALs that use it.
611 */
Stefano Panella5b377172008-12-12 13:00:06 +0000612int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int max_interval)
David Vrabel8cc13a02008-09-17 16:34:09 +0100613{
614 return -ENOSYS;
615}
616EXPORT_SYMBOL_GPL(uwb_rsv_modify);
617
Stefano Panella5b377172008-12-12 13:00:06 +0000618/*
619 * move an already established reservation (rc->rsvs_mutex must to be
620 * taken when tis function is called)
621 */
622int uwb_rsv_try_move(struct uwb_rsv *rsv, struct uwb_mas_bm *available)
623{
624 struct uwb_rc *rc = rsv->rc;
625 struct uwb_drp_backoff_win *bow = &rc->bow;
626 struct device *dev = &rc->uwb_dev.dev;
627 struct uwb_rsv_move *mv;
628 int ret = 0;
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600629
Stefano Panella5b377172008-12-12 13:00:06 +0000630 if (bow->can_reserve_extra_mases == false)
631 return -EBUSY;
632
633 mv = &rsv->mv;
634
635 if (uwb_rsv_find_best_allocation(rsv, available, &mv->final_mas) == UWB_RSV_ALLOC_FOUND) {
636
637 if (!bitmap_equal(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS)) {
638 /* We want to move the reservation */
639 bitmap_andnot(mv->companion_mas.bm, mv->final_mas.bm, rsv->mas.bm, UWB_NUM_MAS);
640 uwb_drp_avail_reserve_pending(rc, &mv->companion_mas);
641 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
642 }
643 } else {
644 dev_dbg(dev, "new allocation not found\n");
645 }
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600646
Stefano Panella5b377172008-12-12 13:00:06 +0000647 return ret;
648}
649
650/* It will try to move every reservation in state O_ESTABLISHED giving
651 * to the MAS allocator algorithm an availability that is the real one
652 * plus the allocation already established from the reservation. */
653void uwb_rsv_handle_drp_avail_change(struct uwb_rc *rc)
654{
655 struct uwb_drp_backoff_win *bow = &rc->bow;
656 struct uwb_rsv *rsv;
657 struct uwb_mas_bm mas;
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600658
Stefano Panella5b377172008-12-12 13:00:06 +0000659 if (bow->can_reserve_extra_mases == false)
660 return;
661
662 list_for_each_entry(rsv, &rc->reservations, rc_node) {
663 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED ||
664 rsv->state == UWB_RSV_STATE_O_TO_BE_MOVED) {
665 uwb_drp_available(rc, &mas);
666 bitmap_or(mas.bm, mas.bm, rsv->mas.bm, UWB_NUM_MAS);
667 uwb_rsv_try_move(rsv, &mas);
668 }
669 }
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600670
Stefano Panella5b377172008-12-12 13:00:06 +0000671}
672
David Vrabel8cc13a02008-09-17 16:34:09 +0100673/**
674 * uwb_rsv_terminate - terminate an established reservation
675 * @rsv: the reservation to terminate
676 *
677 * A reservation is terminated by removing the DRP IE from the beacon,
678 * the other end will consider the reservation to be terminated when
679 * it does not see the DRP IE for at least mMaxLostBeacons.
680 *
681 * If applicable, the reference to the target uwb_dev will be released.
682 */
683void uwb_rsv_terminate(struct uwb_rsv *rsv)
684{
685 struct uwb_rc *rc = rsv->rc;
686
687 mutex_lock(&rc->rsvs_mutex);
688
David Vrabel671e4702008-12-12 13:23:24 +0000689 if (rsv->state != UWB_RSV_STATE_NONE)
690 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
David Vrabel8cc13a02008-09-17 16:34:09 +0100691
692 mutex_unlock(&rc->rsvs_mutex);
693}
694EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
695
696/**
697 * uwb_rsv_accept - accept a new reservation from a peer
698 * @rsv: the reservation
699 * @cb: call back for reservation changes
700 * @pal_priv: data to be passed in the above call back
701 *
702 * Reservation requests from peers are denied unless a PAL accepts it
703 * by calling this function.
David Vrabelcae1c112008-10-27 15:22:46 +0000704 *
705 * The PAL call uwb_rsv_destroy() for all accepted reservations before
706 * calling uwb_pal_unregister().
David Vrabel8cc13a02008-09-17 16:34:09 +0100707 */
708void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
709{
David Vrabelcae1c112008-10-27 15:22:46 +0000710 uwb_rsv_get(rsv);
711
David Vrabel8cc13a02008-09-17 16:34:09 +0100712 rsv->callback = cb;
713 rsv->pal_priv = pal_priv;
714 rsv->state = UWB_RSV_STATE_T_ACCEPTED;
715}
716EXPORT_SYMBOL_GPL(uwb_rsv_accept);
717
718/*
719 * Is a received DRP IE for this reservation?
720 */
721static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
722 struct uwb_ie_drp *drp_ie)
723{
724 struct uwb_dev_addr *rsv_src;
725 int stream;
726
727 stream = uwb_ie_drp_stream_index(drp_ie);
728
729 if (rsv->stream != stream)
730 return false;
731
732 switch (rsv->target.type) {
733 case UWB_RSV_TARGET_DEVADDR:
734 return rsv->stream == stream;
735 case UWB_RSV_TARGET_DEV:
736 if (uwb_ie_drp_owner(drp_ie))
737 rsv_src = &rsv->owner->dev_addr;
738 else
739 rsv_src = &rsv->target.dev->dev_addr;
740 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
741 }
742 return false;
743}
744
745static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
746 struct uwb_dev *src,
747 struct uwb_ie_drp *drp_ie)
748{
749 struct uwb_rsv *rsv;
750 struct uwb_pal *pal;
751 enum uwb_rsv_state state;
752
753 rsv = uwb_rsv_alloc(rc);
754 if (!rsv)
755 return NULL;
756
757 rsv->rc = rc;
758 rsv->owner = src;
759 uwb_dev_get(rsv->owner);
760 rsv->target.type = UWB_RSV_TARGET_DEV;
761 rsv->target.dev = &rc->uwb_dev;
Stefano Panella5b377172008-12-12 13:00:06 +0000762 uwb_dev_get(&rc->uwb_dev);
David Vrabel8cc13a02008-09-17 16:34:09 +0100763 rsv->type = uwb_ie_drp_type(drp_ie);
764 rsv->stream = uwb_ie_drp_stream_index(drp_ie);
David Vrabel8cc13a02008-09-17 16:34:09 +0100765 uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
766
767 /*
768 * See if any PALs are interested in this reservation. If not,
769 * deny the request.
770 */
771 rsv->state = UWB_RSV_STATE_T_DENIED;
David Vrabel6fae35f2008-11-17 15:53:42 +0000772 mutex_lock(&rc->uwb_dev.mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100773 list_for_each_entry(pal, &rc->pals, node) {
774 if (pal->new_rsv)
David Vrabele17be2b2008-11-17 15:24:14 +0000775 pal->new_rsv(pal, rsv);
David Vrabel8cc13a02008-09-17 16:34:09 +0100776 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
777 break;
778 }
David Vrabel6fae35f2008-11-17 15:53:42 +0000779 mutex_unlock(&rc->uwb_dev.mutex);
David Vrabel8cc13a02008-09-17 16:34:09 +0100780
781 list_add_tail(&rsv->rc_node, &rc->reservations);
782 state = rsv->state;
783 rsv->state = UWB_RSV_STATE_NONE;
Stefano Panella5b377172008-12-12 13:00:06 +0000784
785 /* FIXME: do something sensible here */
786 if (state == UWB_RSV_STATE_T_ACCEPTED
787 && uwb_drp_avail_reserve_pending(rc, &rsv->mas) == -EBUSY) {
788 /* FIXME: do something sensible here */
789 } else {
790 uwb_rsv_set_state(rsv, state);
791 }
David Vrabel8cc13a02008-09-17 16:34:09 +0100792
793 return rsv;
794}
795
796/**
Stefano Panella5b377172008-12-12 13:00:06 +0000797 * uwb_rsv_get_usable_mas - get the bitmap of the usable MAS of a reservations
798 * @rsv: the reservation.
799 * @mas: returns the available MAS.
800 *
801 * The usable MAS of a reservation may be less than the negotiated MAS
802 * if alien BPs are present.
803 */
804void uwb_rsv_get_usable_mas(struct uwb_rsv *rsv, struct uwb_mas_bm *mas)
805{
806 bitmap_zero(mas->bm, UWB_NUM_MAS);
807 bitmap_andnot(mas->bm, rsv->mas.bm, rsv->rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
808}
809EXPORT_SYMBOL_GPL(uwb_rsv_get_usable_mas);
810
811/**
David Vrabel8cc13a02008-09-17 16:34:09 +0100812 * uwb_rsv_find - find a reservation for a received DRP IE.
813 * @rc: the radio controller
814 * @src: source of the DRP IE
815 * @drp_ie: the DRP IE
816 *
817 * If the reservation cannot be found and the DRP IE is from a peer
818 * attempting to establish a new reservation, create a new reservation
819 * and add it to the list.
820 */
821struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
822 struct uwb_ie_drp *drp_ie)
823{
824 struct uwb_rsv *rsv;
825
826 list_for_each_entry(rsv, &rc->reservations, rc_node) {
827 if (uwb_rsv_match(rsv, src, drp_ie))
828 return rsv;
829 }
830
831 if (uwb_ie_drp_owner(drp_ie))
832 return uwb_rsv_new_target(rc, src, drp_ie);
833
834 return NULL;
835}
836
837/*
838 * Go through all the reservations and check for timeouts and (if
839 * necessary) update their DRP IEs.
840 *
841 * FIXME: look at building the SET_DRP_IE command here rather than
842 * having to rescan the list in uwb_rc_send_all_drp_ie().
843 */
844static bool uwb_rsv_update_all(struct uwb_rc *rc)
845{
846 struct uwb_rsv *rsv, *t;
847 bool ie_updated = false;
848
849 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
David Vrabel8cc13a02008-09-17 16:34:09 +0100850 if (!rsv->ie_valid) {
851 uwb_drp_ie_update(rsv);
852 ie_updated = true;
853 }
854 }
855
856 return ie_updated;
857}
858
Stefano Panella5b377172008-12-12 13:00:06 +0000859void uwb_rsv_queue_update(struct uwb_rc *rc)
860{
861 unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
862
863 queue_delayed_work(rc->rsv_workq, &rc->rsv_update_work, usecs_to_jiffies(delay_us));
864}
865
866/**
867 * uwb_rsv_sched_update - schedule an update of the DRP IEs
868 * @rc: the radio controller.
869 *
870 * To improve performance and ensure correctness with [ECMA-368] the
871 * number of SET-DRP-IE commands that are done are limited.
872 *
873 * DRP IEs update come from two sources: DRP events from the hardware
874 * which all occur at the beginning of the superframe ('syncronous'
875 * events) and reservation establishment/termination requests from
876 * PALs or timers ('asynchronous' events).
877 *
878 * A delayed work ensures that all the synchronous events result in
879 * one SET-DRP-IE command.
880 *
881 * Additional logic (the set_drp_ie_pending and rsv_updated_postponed
882 * flags) will prevent an asynchrous event starting a SET-DRP-IE
883 * command if one is currently awaiting a response.
884 *
885 * FIXME: this does leave a window where an asynchrous event can delay
886 * the SET-DRP-IE for a synchronous event by one superframe.
887 */
David Vrabel8cc13a02008-09-17 16:34:09 +0100888void uwb_rsv_sched_update(struct uwb_rc *rc)
889{
tpugliese31388872013-05-20 15:09:05 -0500890 spin_lock_irq(&rc->rsvs_lock);
Stefano Panella5b377172008-12-12 13:00:06 +0000891 if (!delayed_work_pending(&rc->rsv_update_work)) {
892 if (rc->set_drp_ie_pending > 0) {
893 rc->set_drp_ie_pending++;
894 goto unlock;
895 }
896 uwb_rsv_queue_update(rc);
897 }
898unlock:
tpugliese31388872013-05-20 15:09:05 -0500899 spin_unlock_irq(&rc->rsvs_lock);
David Vrabel8cc13a02008-09-17 16:34:09 +0100900}
901
902/*
903 * Update DRP IEs and, if necessary, the DRP Availability IE and send
904 * the updated IEs to the radio controller.
905 */
906static void uwb_rsv_update_work(struct work_struct *work)
907{
Stefano Panella5b377172008-12-12 13:00:06 +0000908 struct uwb_rc *rc = container_of(work, struct uwb_rc,
909 rsv_update_work.work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100910 bool ie_updated;
911
912 mutex_lock(&rc->rsvs_mutex);
913
914 ie_updated = uwb_rsv_update_all(rc);
915
916 if (!rc->drp_avail.ie_valid) {
917 uwb_drp_avail_ie_update(rc);
918 ie_updated = true;
919 }
920
Stefano Panella5b377172008-12-12 13:00:06 +0000921 if (ie_updated && (rc->set_drp_ie_pending == 0))
David Vrabel8cc13a02008-09-17 16:34:09 +0100922 uwb_rc_send_all_drp_ie(rc);
923
924 mutex_unlock(&rc->rsvs_mutex);
925}
926
Stefano Panella5b377172008-12-12 13:00:06 +0000927static void uwb_rsv_alien_bp_work(struct work_struct *work)
928{
929 struct uwb_rc *rc = container_of(work, struct uwb_rc,
930 rsv_alien_bp_work.work);
931 struct uwb_rsv *rsv;
932
933 mutex_lock(&rc->rsvs_mutex);
Thomas Pugliese67d0fb22013-12-20 11:54:08 -0600934
Stefano Panella5b377172008-12-12 13:00:06 +0000935 list_for_each_entry(rsv, &rc->reservations, rc_node) {
936 if (rsv->type != UWB_DRP_TYPE_ALIEN_BP) {
Thomas Pugliesebf359df2013-12-20 11:54:09 -0600937 uwb_rsv_callback(rsv);
Stefano Panella5b377172008-12-12 13:00:06 +0000938 }
939 }
940
941 mutex_unlock(&rc->rsvs_mutex);
942}
943
David Vrabel8cc13a02008-09-17 16:34:09 +0100944static void uwb_rsv_timer(unsigned long arg)
945{
946 struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
947
Stefano Panella5b377172008-12-12 13:00:06 +0000948 queue_work(rsv->rc->rsv_workq, &rsv->handle_timeout_work);
David Vrabel8cc13a02008-09-17 16:34:09 +0100949}
950
David Vrabel307ba6d2008-11-07 17:37:33 +0000951/**
952 * uwb_rsv_remove_all - remove all reservations
953 * @rc: the radio controller
954 *
955 * A DRP IE update is not done.
956 */
957void uwb_rsv_remove_all(struct uwb_rc *rc)
958{
959 struct uwb_rsv *rsv, *t;
960
961 mutex_lock(&rc->rsvs_mutex);
962 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
David Vrabel2226b1c2009-01-06 17:55:32 +0000963 if (rsv->state != UWB_RSV_STATE_NONE)
964 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
965 del_timer_sync(&rsv->timer);
David Vrabel307ba6d2008-11-07 17:37:33 +0000966 }
Stefano Panella5b377172008-12-12 13:00:06 +0000967 /* Cancel any postponed update. */
968 rc->set_drp_ie_pending = 0;
David Vrabel307ba6d2008-11-07 17:37:33 +0000969 mutex_unlock(&rc->rsvs_mutex);
970
Stefano Panella5b377172008-12-12 13:00:06 +0000971 cancel_delayed_work_sync(&rc->rsv_update_work);
David Vrabel2226b1c2009-01-06 17:55:32 +0000972 flush_workqueue(rc->rsv_workq);
973
974 mutex_lock(&rc->rsvs_mutex);
975 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
976 uwb_rsv_remove(rsv);
977 }
978 mutex_unlock(&rc->rsvs_mutex);
David Vrabel307ba6d2008-11-07 17:37:33 +0000979}
980
David Vrabel8cc13a02008-09-17 16:34:09 +0100981void uwb_rsv_init(struct uwb_rc *rc)
982{
983 INIT_LIST_HEAD(&rc->reservations);
Stefano Panella5b377172008-12-12 13:00:06 +0000984 INIT_LIST_HEAD(&rc->cnflt_alien_list);
David Vrabel8cc13a02008-09-17 16:34:09 +0100985 mutex_init(&rc->rsvs_mutex);
Stefano Panella5b377172008-12-12 13:00:06 +0000986 spin_lock_init(&rc->rsvs_lock);
987 INIT_DELAYED_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
988 INIT_DELAYED_WORK(&rc->rsv_alien_bp_work, uwb_rsv_alien_bp_work);
989 rc->bow.can_reserve_extra_mases = true;
990 rc->bow.total_expired = 0;
991 rc->bow.window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
992 init_timer(&rc->bow.timer);
993 rc->bow.timer.function = uwb_rsv_backoff_win_timer;
994 rc->bow.timer.data = (unsigned long)&rc->bow;
David Vrabel8cc13a02008-09-17 16:34:09 +0100995
996 bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
997}
998
999int uwb_rsv_setup(struct uwb_rc *rc)
1000{
1001 char name[16];
1002
1003 snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
1004 rc->rsv_workq = create_singlethread_workqueue(name);
1005 if (rc->rsv_workq == NULL)
1006 return -ENOMEM;
1007
1008 return 0;
1009}
1010
1011void uwb_rsv_cleanup(struct uwb_rc *rc)
1012{
David Vrabel307ba6d2008-11-07 17:37:33 +00001013 uwb_rsv_remove_all(rc);
David Vrabel8cc13a02008-09-17 16:34:09 +01001014 destroy_workqueue(rc->rsv_workq);
1015}