Loading...
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#include <linux/slab.h>
21#include <linux/random.h>
22
23#include "uwb-internal.h"
24
25static void uwb_rsv_timer(unsigned long arg);
26
27static const char *rsv_states[] = {
28 [UWB_RSV_STATE_NONE] = "none ",
29 [UWB_RSV_STATE_O_INITIATED] = "o initiated ",
30 [UWB_RSV_STATE_O_PENDING] = "o pending ",
31 [UWB_RSV_STATE_O_MODIFIED] = "o modified ",
32 [UWB_RSV_STATE_O_ESTABLISHED] = "o established ",
33 [UWB_RSV_STATE_O_TO_BE_MOVED] = "o to be moved ",
34 [UWB_RSV_STATE_O_MOVE_EXPANDING] = "o move expanding",
35 [UWB_RSV_STATE_O_MOVE_COMBINING] = "o move combining",
36 [UWB_RSV_STATE_O_MOVE_REDUCING] = "o move reducing ",
37 [UWB_RSV_STATE_T_ACCEPTED] = "t accepted ",
38 [UWB_RSV_STATE_T_CONFLICT] = "t conflict ",
39 [UWB_RSV_STATE_T_PENDING] = "t pending ",
40 [UWB_RSV_STATE_T_DENIED] = "t denied ",
41 [UWB_RSV_STATE_T_RESIZED] = "t resized ",
42 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = "t expanding acc ",
43 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = "t expanding conf",
44 [UWB_RSV_STATE_T_EXPANDING_PENDING] = "t expanding pend",
45 [UWB_RSV_STATE_T_EXPANDING_DENIED] = "t expanding den ",
46};
47
48static const char *rsv_types[] = {
49 [UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
50 [UWB_DRP_TYPE_HARD] = "hard",
51 [UWB_DRP_TYPE_SOFT] = "soft",
52 [UWB_DRP_TYPE_PRIVATE] = "private",
53 [UWB_DRP_TYPE_PCA] = "pca",
54};
55
56bool uwb_rsv_has_two_drp_ies(struct uwb_rsv *rsv)
57{
58 static const bool has_two_drp_ies[] = {
59 [UWB_RSV_STATE_O_INITIATED] = false,
60 [UWB_RSV_STATE_O_PENDING] = false,
61 [UWB_RSV_STATE_O_MODIFIED] = false,
62 [UWB_RSV_STATE_O_ESTABLISHED] = false,
63 [UWB_RSV_STATE_O_TO_BE_MOVED] = false,
64 [UWB_RSV_STATE_O_MOVE_COMBINING] = false,
65 [UWB_RSV_STATE_O_MOVE_REDUCING] = false,
66 [UWB_RSV_STATE_O_MOVE_EXPANDING] = true,
67 [UWB_RSV_STATE_T_ACCEPTED] = false,
68 [UWB_RSV_STATE_T_CONFLICT] = false,
69 [UWB_RSV_STATE_T_PENDING] = false,
70 [UWB_RSV_STATE_T_DENIED] = false,
71 [UWB_RSV_STATE_T_RESIZED] = false,
72 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = true,
73 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = true,
74 [UWB_RSV_STATE_T_EXPANDING_PENDING] = true,
75 [UWB_RSV_STATE_T_EXPANDING_DENIED] = true,
76 };
77
78 return has_two_drp_ies[rsv->state];
79}
80
81/**
82 * uwb_rsv_state_str - return a string for a reservation state
83 * @state: the reservation state.
84 */
85const char *uwb_rsv_state_str(enum uwb_rsv_state state)
86{
87 if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
88 return "unknown";
89 return rsv_states[state];
90}
91EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
92
93/**
94 * uwb_rsv_type_str - return a string for a reservation type
95 * @type: the reservation type
96 */
97const char *uwb_rsv_type_str(enum uwb_drp_type type)
98{
99 if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
100 return "invalid";
101 return rsv_types[type];
102}
103EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
104
105void uwb_rsv_dump(char *text, struct uwb_rsv *rsv)
106{
107 struct device *dev = &rsv->rc->uwb_dev.dev;
108 struct uwb_dev_addr devaddr;
109 char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
110
111 uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
112 if (rsv->target.type == UWB_RSV_TARGET_DEV)
113 devaddr = rsv->target.dev->dev_addr;
114 else
115 devaddr = rsv->target.devaddr;
116 uwb_dev_addr_print(target, sizeof(target), &devaddr);
117
118 dev_dbg(dev, "rsv %s %s -> %s: %s\n",
119 text, owner, target, uwb_rsv_state_str(rsv->state));
120}
121
122static void uwb_rsv_release(struct kref *kref)
123{
124 struct uwb_rsv *rsv = container_of(kref, struct uwb_rsv, kref);
125
126 kfree(rsv);
127}
128
129void uwb_rsv_get(struct uwb_rsv *rsv)
130{
131 kref_get(&rsv->kref);
132}
133
134void uwb_rsv_put(struct uwb_rsv *rsv)
135{
136 kref_put(&rsv->kref, uwb_rsv_release);
137}
138
139/*
140 * Get a free stream index for a reservation.
141 *
142 * If the target is a DevAddr (e.g., a WUSB cluster reservation) then
143 * the stream is allocated from a pool of per-RC stream indexes,
144 * otherwise a unique stream index for the target is selected.
145 */
146static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
147{
148 struct uwb_rc *rc = rsv->rc;
149 struct device *dev = &rc->uwb_dev.dev;
150 unsigned long *streams_bm;
151 int stream;
152
153 switch (rsv->target.type) {
154 case UWB_RSV_TARGET_DEV:
155 streams_bm = rsv->target.dev->streams;
156 break;
157 case UWB_RSV_TARGET_DEVADDR:
158 streams_bm = rc->uwb_dev.streams;
159 break;
160 default:
161 return -EINVAL;
162 }
163
164 stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
165 if (stream >= UWB_NUM_STREAMS)
166 return -EBUSY;
167
168 rsv->stream = stream;
169 set_bit(stream, streams_bm);
170
171 dev_dbg(dev, "get stream %d\n", rsv->stream);
172
173 return 0;
174}
175
176static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
177{
178 struct uwb_rc *rc = rsv->rc;
179 struct device *dev = &rc->uwb_dev.dev;
180 unsigned long *streams_bm;
181
182 switch (rsv->target.type) {
183 case UWB_RSV_TARGET_DEV:
184 streams_bm = rsv->target.dev->streams;
185 break;
186 case UWB_RSV_TARGET_DEVADDR:
187 streams_bm = rc->uwb_dev.streams;
188 break;
189 default:
190 return;
191 }
192
193 clear_bit(rsv->stream, streams_bm);
194
195 dev_dbg(dev, "put stream %d\n", rsv->stream);
196}
197
198void uwb_rsv_backoff_win_timer(unsigned long arg)
199{
200 struct uwb_drp_backoff_win *bow = (struct uwb_drp_backoff_win *)arg;
201 struct uwb_rc *rc = container_of(bow, struct uwb_rc, bow);
202 struct device *dev = &rc->uwb_dev.dev;
203
204 bow->can_reserve_extra_mases = true;
205 if (bow->total_expired <= 4) {
206 bow->total_expired++;
207 } else {
208 /* after 4 backoff window has expired we can exit from
209 * the backoff procedure */
210 bow->total_expired = 0;
211 bow->window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
212 }
213 dev_dbg(dev, "backoff_win_timer total_expired=%d, n=%d\n: ", bow->total_expired, bow->n);
214
215 /* try to relocate all the "to be moved" relocations */
216 uwb_rsv_handle_drp_avail_change(rc);
217}
218
219void uwb_rsv_backoff_win_increment(struct uwb_rc *rc)
220{
221 struct uwb_drp_backoff_win *bow = &rc->bow;
222 struct device *dev = &rc->uwb_dev.dev;
223 unsigned timeout_us;
224
225 dev_dbg(dev, "backoff_win_increment: window=%d\n", bow->window);
226
227 bow->can_reserve_extra_mases = false;
228
229 if((bow->window << 1) == UWB_DRP_BACKOFF_WIN_MAX)
230 return;
231
232 bow->window <<= 1;
233 bow->n = random32() & (bow->window - 1);
234 dev_dbg(dev, "new_window=%d, n=%d\n: ", bow->window, bow->n);
235
236 /* reset the timer associated variables */
237 timeout_us = bow->n * UWB_SUPERFRAME_LENGTH_US;
238 bow->total_expired = 0;
239 mod_timer(&bow->timer, jiffies + usecs_to_jiffies(timeout_us));
240}
241
242static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
243{
244 int sframes = UWB_MAX_LOST_BEACONS;
245
246 /*
247 * Multicast reservations can become established within 1
248 * super frame and should not be terminated if no response is
249 * received.
250 */
251 if (rsv->is_multicast) {
252 if (rsv->state == UWB_RSV_STATE_O_INITIATED
253 || rsv->state == UWB_RSV_STATE_O_MOVE_EXPANDING
254 || rsv->state == UWB_RSV_STATE_O_MOVE_COMBINING
255 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING)
256 sframes = 1;
257 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
258 sframes = 0;
259
260 }
261
262 if (sframes > 0) {
263 /*
264 * Add an additional 2 superframes to account for the
265 * time to send the SET DRP IE command.
266 */
267 unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
268 mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
269 } else
270 del_timer(&rsv->timer);
271}
272
273/*
274 * Update a reservations state, and schedule an update of the
275 * transmitted DRP IEs.
276 */
277static void uwb_rsv_state_update(struct uwb_rsv *rsv,
278 enum uwb_rsv_state new_state)
279{
280 rsv->state = new_state;
281 rsv->ie_valid = false;
282
283 uwb_rsv_dump("SU", rsv);
284
285 uwb_rsv_stroke_timer(rsv);
286 uwb_rsv_sched_update(rsv->rc);
287}
288
289static void uwb_rsv_callback(struct uwb_rsv *rsv)
290{
291 if (rsv->callback)
292 rsv->callback(rsv);
293}
294
295void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
296{
297 struct uwb_rsv_move *mv = &rsv->mv;
298
299 if (rsv->state == new_state) {
300 switch (rsv->state) {
301 case UWB_RSV_STATE_O_ESTABLISHED:
302 case UWB_RSV_STATE_O_MOVE_EXPANDING:
303 case UWB_RSV_STATE_O_MOVE_COMBINING:
304 case UWB_RSV_STATE_O_MOVE_REDUCING:
305 case UWB_RSV_STATE_T_ACCEPTED:
306 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
307 case UWB_RSV_STATE_T_RESIZED:
308 case UWB_RSV_STATE_NONE:
309 uwb_rsv_stroke_timer(rsv);
310 break;
311 default:
312 /* Expecting a state transition so leave timer
313 as-is. */
314 break;
315 }
316 return;
317 }
318
319 uwb_rsv_dump("SC", rsv);
320
321 switch (new_state) {
322 case UWB_RSV_STATE_NONE:
323 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
324 uwb_rsv_callback(rsv);
325 break;
326 case UWB_RSV_STATE_O_INITIATED:
327 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
328 break;
329 case UWB_RSV_STATE_O_PENDING:
330 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
331 break;
332 case UWB_RSV_STATE_O_MODIFIED:
333 /* in the companion there are the MASes to drop */
334 bitmap_andnot(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
335 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MODIFIED);
336 break;
337 case UWB_RSV_STATE_O_ESTABLISHED:
338 if (rsv->state == UWB_RSV_STATE_O_MODIFIED
339 || rsv->state == UWB_RSV_STATE_O_MOVE_REDUCING) {
340 uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
341 rsv->needs_release_companion_mas = false;
342 }
343 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
344 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
345 uwb_rsv_callback(rsv);
346 break;
347 case UWB_RSV_STATE_O_MOVE_EXPANDING:
348 rsv->needs_release_companion_mas = true;
349 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
350 break;
351 case UWB_RSV_STATE_O_MOVE_COMBINING:
352 rsv->needs_release_companion_mas = false;
353 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
354 bitmap_or(rsv->mas.bm, rsv->mas.bm, mv->companion_mas.bm, UWB_NUM_MAS);
355 rsv->mas.safe += mv->companion_mas.safe;
356 rsv->mas.unsafe += mv->companion_mas.unsafe;
357 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
358 break;
359 case UWB_RSV_STATE_O_MOVE_REDUCING:
360 bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
361 rsv->needs_release_companion_mas = true;
362 rsv->mas.safe = mv->final_mas.safe;
363 rsv->mas.unsafe = mv->final_mas.unsafe;
364 bitmap_copy(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS);
365 bitmap_copy(rsv->mas.unsafe_bm, mv->final_mas.unsafe_bm, UWB_NUM_MAS);
366 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
367 break;
368 case UWB_RSV_STATE_T_ACCEPTED:
369 case UWB_RSV_STATE_T_RESIZED:
370 rsv->needs_release_companion_mas = false;
371 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
372 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
373 uwb_rsv_callback(rsv);
374 break;
375 case UWB_RSV_STATE_T_DENIED:
376 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
377 break;
378 case UWB_RSV_STATE_T_CONFLICT:
379 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_CONFLICT);
380 break;
381 case UWB_RSV_STATE_T_PENDING:
382 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_PENDING);
383 break;
384 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
385 rsv->needs_release_companion_mas = true;
386 uwb_drp_avail_reserve(rsv->rc, &mv->companion_mas);
387 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
388 break;
389 default:
390 dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
391 uwb_rsv_state_str(new_state), new_state);
392 }
393}
394
395static void uwb_rsv_handle_timeout_work(struct work_struct *work)
396{
397 struct uwb_rsv *rsv = container_of(work, struct uwb_rsv,
398 handle_timeout_work);
399 struct uwb_rc *rc = rsv->rc;
400
401 mutex_lock(&rc->rsvs_mutex);
402
403 uwb_rsv_dump("TO", rsv);
404
405 switch (rsv->state) {
406 case UWB_RSV_STATE_O_INITIATED:
407 if (rsv->is_multicast) {
408 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
409 goto unlock;
410 }
411 break;
412 case UWB_RSV_STATE_O_MOVE_EXPANDING:
413 if (rsv->is_multicast) {
414 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
415 goto unlock;
416 }
417 break;
418 case UWB_RSV_STATE_O_MOVE_COMBINING:
419 if (rsv->is_multicast) {
420 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
421 goto unlock;
422 }
423 break;
424 case UWB_RSV_STATE_O_MOVE_REDUCING:
425 if (rsv->is_multicast) {
426 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
427 goto unlock;
428 }
429 break;
430 case UWB_RSV_STATE_O_ESTABLISHED:
431 if (rsv->is_multicast)
432 goto unlock;
433 break;
434 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
435 /*
436 * The time out could be for the main or of the
437 * companion DRP, assume it's for the companion and
438 * drop that first. A further time out is required to
439 * drop the main.
440 */
441 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
442 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
443 goto unlock;
444 default:
445 break;
446 }
447
448 uwb_rsv_remove(rsv);
449
450unlock:
451 mutex_unlock(&rc->rsvs_mutex);
452}
453
454static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
455{
456 struct uwb_rsv *rsv;
457
458 rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
459 if (!rsv)
460 return NULL;
461
462 INIT_LIST_HEAD(&rsv->rc_node);
463 INIT_LIST_HEAD(&rsv->pal_node);
464 kref_init(&rsv->kref);
465 init_timer(&rsv->timer);
466 rsv->timer.function = uwb_rsv_timer;
467 rsv->timer.data = (unsigned long)rsv;
468
469 rsv->rc = rc;
470 INIT_WORK(&rsv->handle_timeout_work, uwb_rsv_handle_timeout_work);
471
472 return rsv;
473}
474
475/**
476 * uwb_rsv_create - allocate and initialize a UWB reservation structure
477 * @rc: the radio controller
478 * @cb: callback to use when the reservation completes or terminates
479 * @pal_priv: data private to the PAL to be passed in the callback
480 *
481 * The callback is called when the state of the reservation changes from:
482 *
483 * - pending to accepted
484 * - pending to denined
485 * - accepted to terminated
486 * - pending to terminated
487 */
488struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
489{
490 struct uwb_rsv *rsv;
491
492 rsv = uwb_rsv_alloc(rc);
493 if (!rsv)
494 return NULL;
495
496 rsv->callback = cb;
497 rsv->pal_priv = pal_priv;
498
499 return rsv;
500}
501EXPORT_SYMBOL_GPL(uwb_rsv_create);
502
503void uwb_rsv_remove(struct uwb_rsv *rsv)
504{
505 uwb_rsv_dump("RM", rsv);
506
507 if (rsv->state != UWB_RSV_STATE_NONE)
508 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
509
510 if (rsv->needs_release_companion_mas)
511 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
512 uwb_drp_avail_release(rsv->rc, &rsv->mas);
513
514 if (uwb_rsv_is_owner(rsv))
515 uwb_rsv_put_stream(rsv);
516
517 uwb_dev_put(rsv->owner);
518 if (rsv->target.type == UWB_RSV_TARGET_DEV)
519 uwb_dev_put(rsv->target.dev);
520
521 list_del_init(&rsv->rc_node);
522 uwb_rsv_put(rsv);
523}
524
525/**
526 * uwb_rsv_destroy - free a UWB reservation structure
527 * @rsv: the reservation to free
528 *
529 * The reservation must already be terminated.
530 */
531void uwb_rsv_destroy(struct uwb_rsv *rsv)
532{
533 uwb_rsv_put(rsv);
534}
535EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
536
537/**
538 * usb_rsv_establish - start a reservation establishment
539 * @rsv: the reservation
540 *
541 * The PAL should fill in @rsv's owner, target, type, max_mas,
542 * min_mas, max_interval and is_multicast fields. If the target is a
543 * uwb_dev it must be referenced.
544 *
545 * The reservation's callback will be called when the reservation is
546 * accepted, denied or times out.
547 */
548int uwb_rsv_establish(struct uwb_rsv *rsv)
549{
550 struct uwb_rc *rc = rsv->rc;
551 struct uwb_mas_bm available;
552 int ret;
553
554 mutex_lock(&rc->rsvs_mutex);
555 ret = uwb_rsv_get_stream(rsv);
556 if (ret)
557 goto out;
558
559 rsv->tiebreaker = random32() & 1;
560 /* get available mas bitmap */
561 uwb_drp_available(rc, &available);
562
563 ret = uwb_rsv_find_best_allocation(rsv, &available, &rsv->mas);
564 if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
565 ret = -EBUSY;
566 uwb_rsv_put_stream(rsv);
567 goto out;
568 }
569
570 ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
571 if (ret != 0) {
572 uwb_rsv_put_stream(rsv);
573 goto out;
574 }
575
576 uwb_rsv_get(rsv);
577 list_add_tail(&rsv->rc_node, &rc->reservations);
578 rsv->owner = &rc->uwb_dev;
579 uwb_dev_get(rsv->owner);
580 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
581out:
582 mutex_unlock(&rc->rsvs_mutex);
583 return ret;
584}
585EXPORT_SYMBOL_GPL(uwb_rsv_establish);
586
587/**
588 * uwb_rsv_modify - modify an already established reservation
589 * @rsv: the reservation to modify
590 * @max_mas: new maximum MAS to reserve
591 * @min_mas: new minimum MAS to reserve
592 * @max_interval: new max_interval to use
593 *
594 * FIXME: implement this once there are PALs that use it.
595 */
596int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int max_interval)
597{
598 return -ENOSYS;
599}
600EXPORT_SYMBOL_GPL(uwb_rsv_modify);
601
602/*
603 * move an already established reservation (rc->rsvs_mutex must to be
604 * taken when tis function is called)
605 */
606int uwb_rsv_try_move(struct uwb_rsv *rsv, struct uwb_mas_bm *available)
607{
608 struct uwb_rc *rc = rsv->rc;
609 struct uwb_drp_backoff_win *bow = &rc->bow;
610 struct device *dev = &rc->uwb_dev.dev;
611 struct uwb_rsv_move *mv;
612 int ret = 0;
613
614 if (bow->can_reserve_extra_mases == false)
615 return -EBUSY;
616
617 mv = &rsv->mv;
618
619 if (uwb_rsv_find_best_allocation(rsv, available, &mv->final_mas) == UWB_RSV_ALLOC_FOUND) {
620
621 if (!bitmap_equal(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS)) {
622 /* We want to move the reservation */
623 bitmap_andnot(mv->companion_mas.bm, mv->final_mas.bm, rsv->mas.bm, UWB_NUM_MAS);
624 uwb_drp_avail_reserve_pending(rc, &mv->companion_mas);
625 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
626 }
627 } else {
628 dev_dbg(dev, "new allocation not found\n");
629 }
630
631 return ret;
632}
633
634/* It will try to move every reservation in state O_ESTABLISHED giving
635 * to the MAS allocator algorithm an availability that is the real one
636 * plus the allocation already established from the reservation. */
637void uwb_rsv_handle_drp_avail_change(struct uwb_rc *rc)
638{
639 struct uwb_drp_backoff_win *bow = &rc->bow;
640 struct uwb_rsv *rsv;
641 struct uwb_mas_bm mas;
642
643 if (bow->can_reserve_extra_mases == false)
644 return;
645
646 list_for_each_entry(rsv, &rc->reservations, rc_node) {
647 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED ||
648 rsv->state == UWB_RSV_STATE_O_TO_BE_MOVED) {
649 uwb_drp_available(rc, &mas);
650 bitmap_or(mas.bm, mas.bm, rsv->mas.bm, UWB_NUM_MAS);
651 uwb_rsv_try_move(rsv, &mas);
652 }
653 }
654
655}
656
657/**
658 * uwb_rsv_terminate - terminate an established reservation
659 * @rsv: the reservation to terminate
660 *
661 * A reservation is terminated by removing the DRP IE from the beacon,
662 * the other end will consider the reservation to be terminated when
663 * it does not see the DRP IE for at least mMaxLostBeacons.
664 *
665 * If applicable, the reference to the target uwb_dev will be released.
666 */
667void uwb_rsv_terminate(struct uwb_rsv *rsv)
668{
669 struct uwb_rc *rc = rsv->rc;
670
671 mutex_lock(&rc->rsvs_mutex);
672
673 if (rsv->state != UWB_RSV_STATE_NONE)
674 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
675
676 mutex_unlock(&rc->rsvs_mutex);
677}
678EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
679
680/**
681 * uwb_rsv_accept - accept a new reservation from a peer
682 * @rsv: the reservation
683 * @cb: call back for reservation changes
684 * @pal_priv: data to be passed in the above call back
685 *
686 * Reservation requests from peers are denied unless a PAL accepts it
687 * by calling this function.
688 *
689 * The PAL call uwb_rsv_destroy() for all accepted reservations before
690 * calling uwb_pal_unregister().
691 */
692void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
693{
694 uwb_rsv_get(rsv);
695
696 rsv->callback = cb;
697 rsv->pal_priv = pal_priv;
698 rsv->state = UWB_RSV_STATE_T_ACCEPTED;
699}
700EXPORT_SYMBOL_GPL(uwb_rsv_accept);
701
702/*
703 * Is a received DRP IE for this reservation?
704 */
705static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
706 struct uwb_ie_drp *drp_ie)
707{
708 struct uwb_dev_addr *rsv_src;
709 int stream;
710
711 stream = uwb_ie_drp_stream_index(drp_ie);
712
713 if (rsv->stream != stream)
714 return false;
715
716 switch (rsv->target.type) {
717 case UWB_RSV_TARGET_DEVADDR:
718 return rsv->stream == stream;
719 case UWB_RSV_TARGET_DEV:
720 if (uwb_ie_drp_owner(drp_ie))
721 rsv_src = &rsv->owner->dev_addr;
722 else
723 rsv_src = &rsv->target.dev->dev_addr;
724 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
725 }
726 return false;
727}
728
729static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
730 struct uwb_dev *src,
731 struct uwb_ie_drp *drp_ie)
732{
733 struct uwb_rsv *rsv;
734 struct uwb_pal *pal;
735 enum uwb_rsv_state state;
736
737 rsv = uwb_rsv_alloc(rc);
738 if (!rsv)
739 return NULL;
740
741 rsv->rc = rc;
742 rsv->owner = src;
743 uwb_dev_get(rsv->owner);
744 rsv->target.type = UWB_RSV_TARGET_DEV;
745 rsv->target.dev = &rc->uwb_dev;
746 uwb_dev_get(&rc->uwb_dev);
747 rsv->type = uwb_ie_drp_type(drp_ie);
748 rsv->stream = uwb_ie_drp_stream_index(drp_ie);
749 uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
750
751 /*
752 * See if any PALs are interested in this reservation. If not,
753 * deny the request.
754 */
755 rsv->state = UWB_RSV_STATE_T_DENIED;
756 mutex_lock(&rc->uwb_dev.mutex);
757 list_for_each_entry(pal, &rc->pals, node) {
758 if (pal->new_rsv)
759 pal->new_rsv(pal, rsv);
760 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
761 break;
762 }
763 mutex_unlock(&rc->uwb_dev.mutex);
764
765 list_add_tail(&rsv->rc_node, &rc->reservations);
766 state = rsv->state;
767 rsv->state = UWB_RSV_STATE_NONE;
768
769 /* FIXME: do something sensible here */
770 if (state == UWB_RSV_STATE_T_ACCEPTED
771 && uwb_drp_avail_reserve_pending(rc, &rsv->mas) == -EBUSY) {
772 /* FIXME: do something sensible here */
773 } else {
774 uwb_rsv_set_state(rsv, state);
775 }
776
777 return rsv;
778}
779
780/**
781 * uwb_rsv_get_usable_mas - get the bitmap of the usable MAS of a reservations
782 * @rsv: the reservation.
783 * @mas: returns the available MAS.
784 *
785 * The usable MAS of a reservation may be less than the negotiated MAS
786 * if alien BPs are present.
787 */
788void uwb_rsv_get_usable_mas(struct uwb_rsv *rsv, struct uwb_mas_bm *mas)
789{
790 bitmap_zero(mas->bm, UWB_NUM_MAS);
791 bitmap_andnot(mas->bm, rsv->mas.bm, rsv->rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
792}
793EXPORT_SYMBOL_GPL(uwb_rsv_get_usable_mas);
794
795/**
796 * uwb_rsv_find - find a reservation for a received DRP IE.
797 * @rc: the radio controller
798 * @src: source of the DRP IE
799 * @drp_ie: the DRP IE
800 *
801 * If the reservation cannot be found and the DRP IE is from a peer
802 * attempting to establish a new reservation, create a new reservation
803 * and add it to the list.
804 */
805struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
806 struct uwb_ie_drp *drp_ie)
807{
808 struct uwb_rsv *rsv;
809
810 list_for_each_entry(rsv, &rc->reservations, rc_node) {
811 if (uwb_rsv_match(rsv, src, drp_ie))
812 return rsv;
813 }
814
815 if (uwb_ie_drp_owner(drp_ie))
816 return uwb_rsv_new_target(rc, src, drp_ie);
817
818 return NULL;
819}
820
821/*
822 * Go through all the reservations and check for timeouts and (if
823 * necessary) update their DRP IEs.
824 *
825 * FIXME: look at building the SET_DRP_IE command here rather than
826 * having to rescan the list in uwb_rc_send_all_drp_ie().
827 */
828static bool uwb_rsv_update_all(struct uwb_rc *rc)
829{
830 struct uwb_rsv *rsv, *t;
831 bool ie_updated = false;
832
833 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
834 if (!rsv->ie_valid) {
835 uwb_drp_ie_update(rsv);
836 ie_updated = true;
837 }
838 }
839
840 return ie_updated;
841}
842
843void uwb_rsv_queue_update(struct uwb_rc *rc)
844{
845 unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
846
847 queue_delayed_work(rc->rsv_workq, &rc->rsv_update_work, usecs_to_jiffies(delay_us));
848}
849
850/**
851 * uwb_rsv_sched_update - schedule an update of the DRP IEs
852 * @rc: the radio controller.
853 *
854 * To improve performance and ensure correctness with [ECMA-368] the
855 * number of SET-DRP-IE commands that are done are limited.
856 *
857 * DRP IEs update come from two sources: DRP events from the hardware
858 * which all occur at the beginning of the superframe ('syncronous'
859 * events) and reservation establishment/termination requests from
860 * PALs or timers ('asynchronous' events).
861 *
862 * A delayed work ensures that all the synchronous events result in
863 * one SET-DRP-IE command.
864 *
865 * Additional logic (the set_drp_ie_pending and rsv_updated_postponed
866 * flags) will prevent an asynchrous event starting a SET-DRP-IE
867 * command if one is currently awaiting a response.
868 *
869 * FIXME: this does leave a window where an asynchrous event can delay
870 * the SET-DRP-IE for a synchronous event by one superframe.
871 */
872void uwb_rsv_sched_update(struct uwb_rc *rc)
873{
874 spin_lock_bh(&rc->rsvs_lock);
875 if (!delayed_work_pending(&rc->rsv_update_work)) {
876 if (rc->set_drp_ie_pending > 0) {
877 rc->set_drp_ie_pending++;
878 goto unlock;
879 }
880 uwb_rsv_queue_update(rc);
881 }
882unlock:
883 spin_unlock_bh(&rc->rsvs_lock);
884}
885
886/*
887 * Update DRP IEs and, if necessary, the DRP Availability IE and send
888 * the updated IEs to the radio controller.
889 */
890static void uwb_rsv_update_work(struct work_struct *work)
891{
892 struct uwb_rc *rc = container_of(work, struct uwb_rc,
893 rsv_update_work.work);
894 bool ie_updated;
895
896 mutex_lock(&rc->rsvs_mutex);
897
898 ie_updated = uwb_rsv_update_all(rc);
899
900 if (!rc->drp_avail.ie_valid) {
901 uwb_drp_avail_ie_update(rc);
902 ie_updated = true;
903 }
904
905 if (ie_updated && (rc->set_drp_ie_pending == 0))
906 uwb_rc_send_all_drp_ie(rc);
907
908 mutex_unlock(&rc->rsvs_mutex);
909}
910
911static void uwb_rsv_alien_bp_work(struct work_struct *work)
912{
913 struct uwb_rc *rc = container_of(work, struct uwb_rc,
914 rsv_alien_bp_work.work);
915 struct uwb_rsv *rsv;
916
917 mutex_lock(&rc->rsvs_mutex);
918
919 list_for_each_entry(rsv, &rc->reservations, rc_node) {
920 if (rsv->type != UWB_DRP_TYPE_ALIEN_BP) {
921 rsv->callback(rsv);
922 }
923 }
924
925 mutex_unlock(&rc->rsvs_mutex);
926}
927
928static void uwb_rsv_timer(unsigned long arg)
929{
930 struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
931
932 queue_work(rsv->rc->rsv_workq, &rsv->handle_timeout_work);
933}
934
935/**
936 * uwb_rsv_remove_all - remove all reservations
937 * @rc: the radio controller
938 *
939 * A DRP IE update is not done.
940 */
941void uwb_rsv_remove_all(struct uwb_rc *rc)
942{
943 struct uwb_rsv *rsv, *t;
944
945 mutex_lock(&rc->rsvs_mutex);
946 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
947 if (rsv->state != UWB_RSV_STATE_NONE)
948 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
949 del_timer_sync(&rsv->timer);
950 }
951 /* Cancel any postponed update. */
952 rc->set_drp_ie_pending = 0;
953 mutex_unlock(&rc->rsvs_mutex);
954
955 cancel_delayed_work_sync(&rc->rsv_update_work);
956 flush_workqueue(rc->rsv_workq);
957
958 mutex_lock(&rc->rsvs_mutex);
959 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
960 uwb_rsv_remove(rsv);
961 }
962 mutex_unlock(&rc->rsvs_mutex);
963}
964
965void uwb_rsv_init(struct uwb_rc *rc)
966{
967 INIT_LIST_HEAD(&rc->reservations);
968 INIT_LIST_HEAD(&rc->cnflt_alien_list);
969 mutex_init(&rc->rsvs_mutex);
970 spin_lock_init(&rc->rsvs_lock);
971 INIT_DELAYED_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
972 INIT_DELAYED_WORK(&rc->rsv_alien_bp_work, uwb_rsv_alien_bp_work);
973 rc->bow.can_reserve_extra_mases = true;
974 rc->bow.total_expired = 0;
975 rc->bow.window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
976 init_timer(&rc->bow.timer);
977 rc->bow.timer.function = uwb_rsv_backoff_win_timer;
978 rc->bow.timer.data = (unsigned long)&rc->bow;
979
980 bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
981}
982
983int uwb_rsv_setup(struct uwb_rc *rc)
984{
985 char name[16];
986
987 snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
988 rc->rsv_workq = create_singlethread_workqueue(name);
989 if (rc->rsv_workq == NULL)
990 return -ENOMEM;
991
992 return 0;
993}
994
995void uwb_rsv_cleanup(struct uwb_rc *rc)
996{
997 uwb_rsv_remove_all(rc);
998 destroy_workqueue(rc->rsv_workq);
999}
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#include <linux/slab.h>
21#include <linux/random.h>
22#include <linux/export.h>
23
24#include "uwb-internal.h"
25
26static void uwb_rsv_timer(struct timer_list *t);
27
28static const char *rsv_states[] = {
29 [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 ",
47};
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
57bool 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
82/**
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
106void uwb_rsv_dump(char *text, struct uwb_rsv *rsv)
107{
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
119 dev_dbg(dev, "rsv %s %s -> %s: %s\n",
120 text, owner, target, uwb_rsv_state_str(rsv->state));
121}
122
123static 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
130void uwb_rsv_get(struct uwb_rsv *rsv)
131{
132 kref_get(&rsv->kref);
133}
134
135void uwb_rsv_put(struct uwb_rsv *rsv)
136{
137 kref_put(&rsv->kref, uwb_rsv_release);
138}
139
140/*
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;
150 struct device *dev = &rc->uwb_dev.dev;
151 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);
166 if (stream >= UWB_NUM_STREAMS) {
167 dev_err(dev, "%s: no available stream found\n", __func__);
168 return -EBUSY;
169 }
170
171 rsv->stream = stream;
172 set_bit(stream, streams_bm);
173
174 dev_dbg(dev, "get stream %d\n", rsv->stream);
175
176 return 0;
177}
178
179static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
180{
181 struct uwb_rc *rc = rsv->rc;
182 struct device *dev = &rc->uwb_dev.dev;
183 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);
197
198 dev_dbg(dev, "put stream %d\n", rsv->stream);
199}
200
201void uwb_rsv_backoff_win_timer(struct timer_list *t)
202{
203 struct uwb_drp_backoff_win *bow = from_timer(bow, t, timer);
204 struct uwb_rc *rc = container_of(bow, struct uwb_rc, bow);
205 struct device *dev = &rc->uwb_dev.dev;
206
207 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;
215 }
216 dev_dbg(dev, "backoff_win_timer total_expired=%d, n=%d\n", bow->total_expired, bow->n);
217
218 /* try to relocate all the "to be moved" relocations */
219 uwb_rsv_handle_drp_avail_change(rc);
220}
221
222void uwb_rsv_backoff_win_increment(struct uwb_rc *rc)
223{
224 struct uwb_drp_backoff_win *bow = &rc->bow;
225 struct device *dev = &rc->uwb_dev.dev;
226 unsigned timeout_us;
227
228 dev_dbg(dev, "backoff_win_increment: window=%d\n", bow->window);
229
230 bow->can_reserve_extra_mases = false;
231
232 if((bow->window << 1) == UWB_DRP_BACKOFF_WIN_MAX)
233 return;
234
235 bow->window <<= 1;
236 bow->n = prandom_u32() & (bow->window - 1);
237 dev_dbg(dev, "new_window=%d, n=%d\n", bow->window, bow->n);
238
239 /* reset the timer associated variables */
240 timeout_us = bow->n * UWB_SUPERFRAME_LENGTH_US;
241 bow->total_expired = 0;
242 mod_timer(&bow->timer, jiffies + usecs_to_jiffies(timeout_us));
243}
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 */
254 if (rsv->state == UWB_RSV_STATE_NONE) {
255 sframes = 0;
256 } else if (rsv->is_multicast) {
257 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)
261 sframes = 1;
262 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
263 sframes = 0;
264
265 }
266
267 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
288 uwb_rsv_dump("SU", rsv);
289
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{
302 struct uwb_rsv_move *mv = &rsv->mv;
303
304 if (rsv->state == new_state) {
305 switch (rsv->state) {
306 case UWB_RSV_STATE_O_ESTABLISHED:
307 case UWB_RSV_STATE_O_MOVE_EXPANDING:
308 case UWB_RSV_STATE_O_MOVE_COMBINING:
309 case UWB_RSV_STATE_O_MOVE_REDUCING:
310 case UWB_RSV_STATE_T_ACCEPTED:
311 case UWB_RSV_STATE_T_EXPANDING_ACCEPTED:
312 case UWB_RSV_STATE_T_RESIZED:
313 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
324 uwb_rsv_dump("SC", rsv);
325
326 switch (new_state) {
327 case UWB_RSV_STATE_NONE:
328 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
329 uwb_rsv_remove(rsv);
330 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;
338 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;
343 case UWB_RSV_STATE_O_ESTABLISHED:
344 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 }
349 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;
353 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;
374 case UWB_RSV_STATE_T_ACCEPTED:
375 case UWB_RSV_STATE_T_RESIZED:
376 rsv->needs_release_companion_mas = false;
377 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;
384 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;
395 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
401static 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;
450 case UWB_RSV_STATE_NONE:
451 goto unlock;
452 default:
453 break;
454 }
455
456 uwb_rsv_remove(rsv);
457
458unlock:
459 mutex_unlock(&rc->rsvs_mutex);
460}
461
462static 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);
472 kref_init(&rsv->kref);
473 timer_setup(&rsv->timer, uwb_rsv_timer, 0);
474
475 rsv->rc = rc;
476 INIT_WORK(&rsv->handle_timeout_work, uwb_rsv_handle_timeout_work);
477
478 return rsv;
479}
480
481/**
482 * uwb_rsv_create - allocate and initialize a UWB reservation structure
483 * @rc: the radio controller
484 * @cb: callback to use when the reservation completes or terminates
485 * @pal_priv: data private to the PAL to be passed in the callback
486 *
487 * The callback is called when the state of the reservation changes from:
488 *
489 * - pending to accepted
490 * - pending to denined
491 * - accepted to terminated
492 * - pending to terminated
493 */
494struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
495{
496 struct uwb_rsv *rsv;
497
498 rsv = uwb_rsv_alloc(rc);
499 if (!rsv)
500 return NULL;
501
502 rsv->callback = cb;
503 rsv->pal_priv = pal_priv;
504
505 return rsv;
506}
507EXPORT_SYMBOL_GPL(uwb_rsv_create);
508
509void uwb_rsv_remove(struct uwb_rsv *rsv)
510{
511 uwb_rsv_dump("RM", rsv);
512
513 if (rsv->state != UWB_RSV_STATE_NONE)
514 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
515
516 if (rsv->needs_release_companion_mas)
517 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
518 uwb_drp_avail_release(rsv->rc, &rsv->mas);
519
520 if (uwb_rsv_is_owner(rsv))
521 uwb_rsv_put_stream(rsv);
522
523 uwb_dev_put(rsv->owner);
524 if (rsv->target.type == UWB_RSV_TARGET_DEV)
525 uwb_dev_put(rsv->target.dev);
526
527 list_del_init(&rsv->rc_node);
528 uwb_rsv_put(rsv);
529}
530
531/**
532 * uwb_rsv_destroy - free a UWB reservation structure
533 * @rsv: the reservation to free
534 *
535 * The reservation must already be terminated.
536 */
537void uwb_rsv_destroy(struct uwb_rsv *rsv)
538{
539 uwb_rsv_put(rsv);
540}
541EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
542
543/**
544 * usb_rsv_establish - start a reservation establishment
545 * @rsv: the reservation
546 *
547 * The PAL should fill in @rsv's owner, target, type, max_mas,
548 * min_mas, max_interval and is_multicast fields. If the target is a
549 * uwb_dev it must be referenced.
550 *
551 * The reservation's callback will be called when the reservation is
552 * accepted, denied or times out.
553 */
554int uwb_rsv_establish(struct uwb_rsv *rsv)
555{
556 struct uwb_rc *rc = rsv->rc;
557 struct uwb_mas_bm available;
558 struct device *dev = &rc->uwb_dev.dev;
559 int ret;
560
561 mutex_lock(&rc->rsvs_mutex);
562 ret = uwb_rsv_get_stream(rsv);
563 if (ret) {
564 dev_err(dev, "%s: uwb_rsv_get_stream failed: %d\n",
565 __func__, ret);
566 goto out;
567 }
568
569 rsv->tiebreaker = prandom_u32() & 1;
570 /* get available mas bitmap */
571 uwb_drp_available(rc, &available);
572
573 ret = uwb_rsv_find_best_allocation(rsv, &available, &rsv->mas);
574 if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
575 ret = -EBUSY;
576 uwb_rsv_put_stream(rsv);
577 dev_err(dev, "%s: uwb_rsv_find_best_allocation failed: %d\n",
578 __func__, ret);
579 goto out;
580 }
581
582 ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
583 if (ret != 0) {
584 uwb_rsv_put_stream(rsv);
585 dev_err(dev, "%s: uwb_drp_avail_reserve_pending failed: %d\n",
586 __func__, ret);
587 goto out;
588 }
589
590 uwb_rsv_get(rsv);
591 list_add_tail(&rsv->rc_node, &rc->reservations);
592 rsv->owner = &rc->uwb_dev;
593 uwb_dev_get(rsv->owner);
594 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
595out:
596 mutex_unlock(&rc->rsvs_mutex);
597 return ret;
598}
599EXPORT_SYMBOL_GPL(uwb_rsv_establish);
600
601/**
602 * uwb_rsv_modify - modify an already established reservation
603 * @rsv: the reservation to modify
604 * @max_mas: new maximum MAS to reserve
605 * @min_mas: new minimum MAS to reserve
606 * @max_interval: new max_interval to use
607 *
608 * FIXME: implement this once there are PALs that use it.
609 */
610int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int max_interval)
611{
612 return -ENOSYS;
613}
614EXPORT_SYMBOL_GPL(uwb_rsv_modify);
615
616/*
617 * move an already established reservation (rc->rsvs_mutex must to be
618 * taken when tis function is called)
619 */
620int uwb_rsv_try_move(struct uwb_rsv *rsv, struct uwb_mas_bm *available)
621{
622 struct uwb_rc *rc = rsv->rc;
623 struct uwb_drp_backoff_win *bow = &rc->bow;
624 struct device *dev = &rc->uwb_dev.dev;
625 struct uwb_rsv_move *mv;
626 int ret = 0;
627
628 if (bow->can_reserve_extra_mases == false)
629 return -EBUSY;
630
631 mv = &rsv->mv;
632
633 if (uwb_rsv_find_best_allocation(rsv, available, &mv->final_mas) == UWB_RSV_ALLOC_FOUND) {
634
635 if (!bitmap_equal(rsv->mas.bm, mv->final_mas.bm, UWB_NUM_MAS)) {
636 /* We want to move the reservation */
637 bitmap_andnot(mv->companion_mas.bm, mv->final_mas.bm, rsv->mas.bm, UWB_NUM_MAS);
638 uwb_drp_avail_reserve_pending(rc, &mv->companion_mas);
639 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
640 }
641 } else {
642 dev_dbg(dev, "new allocation not found\n");
643 }
644
645 return ret;
646}
647
648/* It will try to move every reservation in state O_ESTABLISHED giving
649 * to the MAS allocator algorithm an availability that is the real one
650 * plus the allocation already established from the reservation. */
651void uwb_rsv_handle_drp_avail_change(struct uwb_rc *rc)
652{
653 struct uwb_drp_backoff_win *bow = &rc->bow;
654 struct uwb_rsv *rsv;
655 struct uwb_mas_bm mas;
656
657 if (bow->can_reserve_extra_mases == false)
658 return;
659
660 list_for_each_entry(rsv, &rc->reservations, rc_node) {
661 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED ||
662 rsv->state == UWB_RSV_STATE_O_TO_BE_MOVED) {
663 uwb_drp_available(rc, &mas);
664 bitmap_or(mas.bm, mas.bm, rsv->mas.bm, UWB_NUM_MAS);
665 uwb_rsv_try_move(rsv, &mas);
666 }
667 }
668
669}
670
671/**
672 * uwb_rsv_terminate - terminate an established reservation
673 * @rsv: the reservation to terminate
674 *
675 * A reservation is terminated by removing the DRP IE from the beacon,
676 * the other end will consider the reservation to be terminated when
677 * it does not see the DRP IE for at least mMaxLostBeacons.
678 *
679 * If applicable, the reference to the target uwb_dev will be released.
680 */
681void uwb_rsv_terminate(struct uwb_rsv *rsv)
682{
683 struct uwb_rc *rc = rsv->rc;
684
685 mutex_lock(&rc->rsvs_mutex);
686
687 if (rsv->state != UWB_RSV_STATE_NONE)
688 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
689
690 mutex_unlock(&rc->rsvs_mutex);
691}
692EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
693
694/**
695 * uwb_rsv_accept - accept a new reservation from a peer
696 * @rsv: the reservation
697 * @cb: call back for reservation changes
698 * @pal_priv: data to be passed in the above call back
699 *
700 * Reservation requests from peers are denied unless a PAL accepts it
701 * by calling this function.
702 *
703 * The PAL call uwb_rsv_destroy() for all accepted reservations before
704 * calling uwb_pal_unregister().
705 */
706void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
707{
708 uwb_rsv_get(rsv);
709
710 rsv->callback = cb;
711 rsv->pal_priv = pal_priv;
712 rsv->state = UWB_RSV_STATE_T_ACCEPTED;
713}
714EXPORT_SYMBOL_GPL(uwb_rsv_accept);
715
716/*
717 * Is a received DRP IE for this reservation?
718 */
719static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
720 struct uwb_ie_drp *drp_ie)
721{
722 struct uwb_dev_addr *rsv_src;
723 int stream;
724
725 stream = uwb_ie_drp_stream_index(drp_ie);
726
727 if (rsv->stream != stream)
728 return false;
729
730 switch (rsv->target.type) {
731 case UWB_RSV_TARGET_DEVADDR:
732 return rsv->stream == stream;
733 case UWB_RSV_TARGET_DEV:
734 if (uwb_ie_drp_owner(drp_ie))
735 rsv_src = &rsv->owner->dev_addr;
736 else
737 rsv_src = &rsv->target.dev->dev_addr;
738 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
739 }
740 return false;
741}
742
743static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
744 struct uwb_dev *src,
745 struct uwb_ie_drp *drp_ie)
746{
747 struct uwb_rsv *rsv;
748 struct uwb_pal *pal;
749 enum uwb_rsv_state state;
750
751 rsv = uwb_rsv_alloc(rc);
752 if (!rsv)
753 return NULL;
754
755 rsv->rc = rc;
756 rsv->owner = src;
757 uwb_dev_get(rsv->owner);
758 rsv->target.type = UWB_RSV_TARGET_DEV;
759 rsv->target.dev = &rc->uwb_dev;
760 uwb_dev_get(&rc->uwb_dev);
761 rsv->type = uwb_ie_drp_type(drp_ie);
762 rsv->stream = uwb_ie_drp_stream_index(drp_ie);
763 uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
764
765 /*
766 * See if any PALs are interested in this reservation. If not,
767 * deny the request.
768 */
769 rsv->state = UWB_RSV_STATE_T_DENIED;
770 mutex_lock(&rc->uwb_dev.mutex);
771 list_for_each_entry(pal, &rc->pals, node) {
772 if (pal->new_rsv)
773 pal->new_rsv(pal, rsv);
774 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
775 break;
776 }
777 mutex_unlock(&rc->uwb_dev.mutex);
778
779 list_add_tail(&rsv->rc_node, &rc->reservations);
780 state = rsv->state;
781 rsv->state = UWB_RSV_STATE_NONE;
782
783 /* FIXME: do something sensible here */
784 if (state == UWB_RSV_STATE_T_ACCEPTED
785 && uwb_drp_avail_reserve_pending(rc, &rsv->mas) == -EBUSY) {
786 /* FIXME: do something sensible here */
787 } else {
788 uwb_rsv_set_state(rsv, state);
789 }
790
791 return rsv;
792}
793
794/**
795 * uwb_rsv_get_usable_mas - get the bitmap of the usable MAS of a reservations
796 * @rsv: the reservation.
797 * @mas: returns the available MAS.
798 *
799 * The usable MAS of a reservation may be less than the negotiated MAS
800 * if alien BPs are present.
801 */
802void uwb_rsv_get_usable_mas(struct uwb_rsv *rsv, struct uwb_mas_bm *mas)
803{
804 bitmap_zero(mas->bm, UWB_NUM_MAS);
805 bitmap_andnot(mas->bm, rsv->mas.bm, rsv->rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
806}
807EXPORT_SYMBOL_GPL(uwb_rsv_get_usable_mas);
808
809/**
810 * uwb_rsv_find - find a reservation for a received DRP IE.
811 * @rc: the radio controller
812 * @src: source of the DRP IE
813 * @drp_ie: the DRP IE
814 *
815 * If the reservation cannot be found and the DRP IE is from a peer
816 * attempting to establish a new reservation, create a new reservation
817 * and add it to the list.
818 */
819struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
820 struct uwb_ie_drp *drp_ie)
821{
822 struct uwb_rsv *rsv;
823
824 list_for_each_entry(rsv, &rc->reservations, rc_node) {
825 if (uwb_rsv_match(rsv, src, drp_ie))
826 return rsv;
827 }
828
829 if (uwb_ie_drp_owner(drp_ie))
830 return uwb_rsv_new_target(rc, src, drp_ie);
831
832 return NULL;
833}
834
835/*
836 * Go through all the reservations and check for timeouts and (if
837 * necessary) update their DRP IEs.
838 *
839 * FIXME: look at building the SET_DRP_IE command here rather than
840 * having to rescan the list in uwb_rc_send_all_drp_ie().
841 */
842static bool uwb_rsv_update_all(struct uwb_rc *rc)
843{
844 struct uwb_rsv *rsv, *t;
845 bool ie_updated = false;
846
847 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
848 if (!rsv->ie_valid) {
849 uwb_drp_ie_update(rsv);
850 ie_updated = true;
851 }
852 }
853
854 return ie_updated;
855}
856
857void uwb_rsv_queue_update(struct uwb_rc *rc)
858{
859 unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
860
861 queue_delayed_work(rc->rsv_workq, &rc->rsv_update_work, usecs_to_jiffies(delay_us));
862}
863
864/**
865 * uwb_rsv_sched_update - schedule an update of the DRP IEs
866 * @rc: the radio controller.
867 *
868 * To improve performance and ensure correctness with [ECMA-368] the
869 * number of SET-DRP-IE commands that are done are limited.
870 *
871 * DRP IEs update come from two sources: DRP events from the hardware
872 * which all occur at the beginning of the superframe ('syncronous'
873 * events) and reservation establishment/termination requests from
874 * PALs or timers ('asynchronous' events).
875 *
876 * A delayed work ensures that all the synchronous events result in
877 * one SET-DRP-IE command.
878 *
879 * Additional logic (the set_drp_ie_pending and rsv_updated_postponed
880 * flags) will prevent an asynchrous event starting a SET-DRP-IE
881 * command if one is currently awaiting a response.
882 *
883 * FIXME: this does leave a window where an asynchrous event can delay
884 * the SET-DRP-IE for a synchronous event by one superframe.
885 */
886void uwb_rsv_sched_update(struct uwb_rc *rc)
887{
888 spin_lock_irq(&rc->rsvs_lock);
889 if (!delayed_work_pending(&rc->rsv_update_work)) {
890 if (rc->set_drp_ie_pending > 0) {
891 rc->set_drp_ie_pending++;
892 goto unlock;
893 }
894 uwb_rsv_queue_update(rc);
895 }
896unlock:
897 spin_unlock_irq(&rc->rsvs_lock);
898}
899
900/*
901 * Update DRP IEs and, if necessary, the DRP Availability IE and send
902 * the updated IEs to the radio controller.
903 */
904static void uwb_rsv_update_work(struct work_struct *work)
905{
906 struct uwb_rc *rc = container_of(work, struct uwb_rc,
907 rsv_update_work.work);
908 bool ie_updated;
909
910 mutex_lock(&rc->rsvs_mutex);
911
912 ie_updated = uwb_rsv_update_all(rc);
913
914 if (!rc->drp_avail.ie_valid) {
915 uwb_drp_avail_ie_update(rc);
916 ie_updated = true;
917 }
918
919 if (ie_updated && (rc->set_drp_ie_pending == 0))
920 uwb_rc_send_all_drp_ie(rc);
921
922 mutex_unlock(&rc->rsvs_mutex);
923}
924
925static void uwb_rsv_alien_bp_work(struct work_struct *work)
926{
927 struct uwb_rc *rc = container_of(work, struct uwb_rc,
928 rsv_alien_bp_work.work);
929 struct uwb_rsv *rsv;
930
931 mutex_lock(&rc->rsvs_mutex);
932
933 list_for_each_entry(rsv, &rc->reservations, rc_node) {
934 if (rsv->type != UWB_DRP_TYPE_ALIEN_BP) {
935 uwb_rsv_callback(rsv);
936 }
937 }
938
939 mutex_unlock(&rc->rsvs_mutex);
940}
941
942static void uwb_rsv_timer(struct timer_list *t)
943{
944 struct uwb_rsv *rsv = from_timer(rsv, t, timer);
945
946 queue_work(rsv->rc->rsv_workq, &rsv->handle_timeout_work);
947}
948
949/**
950 * uwb_rsv_remove_all - remove all reservations
951 * @rc: the radio controller
952 *
953 * A DRP IE update is not done.
954 */
955void uwb_rsv_remove_all(struct uwb_rc *rc)
956{
957 struct uwb_rsv *rsv, *t;
958
959 mutex_lock(&rc->rsvs_mutex);
960 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
961 if (rsv->state != UWB_RSV_STATE_NONE)
962 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
963 del_timer_sync(&rsv->timer);
964 }
965 /* Cancel any postponed update. */
966 rc->set_drp_ie_pending = 0;
967 mutex_unlock(&rc->rsvs_mutex);
968
969 cancel_delayed_work_sync(&rc->rsv_update_work);
970 flush_workqueue(rc->rsv_workq);
971
972 mutex_lock(&rc->rsvs_mutex);
973 list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
974 uwb_rsv_remove(rsv);
975 }
976 mutex_unlock(&rc->rsvs_mutex);
977}
978
979void uwb_rsv_init(struct uwb_rc *rc)
980{
981 INIT_LIST_HEAD(&rc->reservations);
982 INIT_LIST_HEAD(&rc->cnflt_alien_list);
983 mutex_init(&rc->rsvs_mutex);
984 spin_lock_init(&rc->rsvs_lock);
985 INIT_DELAYED_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
986 INIT_DELAYED_WORK(&rc->rsv_alien_bp_work, uwb_rsv_alien_bp_work);
987 rc->bow.can_reserve_extra_mases = true;
988 rc->bow.total_expired = 0;
989 rc->bow.window = UWB_DRP_BACKOFF_WIN_MIN >> 1;
990 timer_setup(&rc->bow.timer, uwb_rsv_backoff_win_timer, 0);
991
992 bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
993}
994
995int uwb_rsv_setup(struct uwb_rc *rc)
996{
997 char name[16];
998
999 snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
1000 rc->rsv_workq = create_singlethread_workqueue(name);
1001 if (rc->rsv_workq == NULL)
1002 return -ENOMEM;
1003
1004 return 0;
1005}
1006
1007void uwb_rsv_cleanup(struct uwb_rc *rc)
1008{
1009 uwb_rsv_remove_all(rc);
1010 destroy_workqueue(rc->rsv_workq);
1011}