Merge branch 'for-linus' of git://neil.brown.name/md
[linux-2.6.git] / drivers / uwb / rsv.c
1 /*
2  * UWB reservation management.
3  *
4  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License version
8  * 2 as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 #include <linux/version.h>
19 #include <linux/kernel.h>
20 #include <linux/uwb.h>
21
22 #include "uwb-internal.h"
23
24 static void uwb_rsv_timer(unsigned long arg);
25
26 static const char *rsv_states[] = {
27         [UWB_RSV_STATE_NONE]          = "none",
28         [UWB_RSV_STATE_O_INITIATED]   = "initiated",
29         [UWB_RSV_STATE_O_PENDING]     = "pending",
30         [UWB_RSV_STATE_O_MODIFIED]    = "modified",
31         [UWB_RSV_STATE_O_ESTABLISHED] = "established",
32         [UWB_RSV_STATE_T_ACCEPTED]    = "accepted",
33         [UWB_RSV_STATE_T_DENIED]      = "denied",
34         [UWB_RSV_STATE_T_PENDING]     = "pending",
35 };
36
37 static const char *rsv_types[] = {
38         [UWB_DRP_TYPE_ALIEN_BP] = "alien-bp",
39         [UWB_DRP_TYPE_HARD]     = "hard",
40         [UWB_DRP_TYPE_SOFT]     = "soft",
41         [UWB_DRP_TYPE_PRIVATE]  = "private",
42         [UWB_DRP_TYPE_PCA]      = "pca",
43 };
44
45 /**
46  * uwb_rsv_state_str - return a string for a reservation state
47  * @state: the reservation state.
48  */
49 const char *uwb_rsv_state_str(enum uwb_rsv_state state)
50 {
51         if (state < UWB_RSV_STATE_NONE || state >= UWB_RSV_STATE_LAST)
52                 return "unknown";
53         return rsv_states[state];
54 }
55 EXPORT_SYMBOL_GPL(uwb_rsv_state_str);
56
57 /**
58  * uwb_rsv_type_str - return a string for a reservation type
59  * @type: the reservation type
60  */
61 const char *uwb_rsv_type_str(enum uwb_drp_type type)
62 {
63         if (type < UWB_DRP_TYPE_ALIEN_BP || type > UWB_DRP_TYPE_PCA)
64                 return "invalid";
65         return rsv_types[type];
66 }
67 EXPORT_SYMBOL_GPL(uwb_rsv_type_str);
68
69 static void uwb_rsv_dump(struct uwb_rsv *rsv)
70 {
71         struct device *dev = &rsv->rc->uwb_dev.dev;
72         struct uwb_dev_addr devaddr;
73         char owner[UWB_ADDR_STRSIZE], target[UWB_ADDR_STRSIZE];
74
75         uwb_dev_addr_print(owner, sizeof(owner), &rsv->owner->dev_addr);
76         if (rsv->target.type == UWB_RSV_TARGET_DEV)
77                 devaddr = rsv->target.dev->dev_addr;
78         else
79                 devaddr = rsv->target.devaddr;
80         uwb_dev_addr_print(target, sizeof(target), &devaddr);
81
82         dev_dbg(dev, "rsv %s -> %s: %s\n", owner, target, uwb_rsv_state_str(rsv->state));
83 }
84
85 /*
86  * Get a free stream index for a reservation.
87  *
88  * If the target is a DevAddr (e.g., a WUSB cluster reservation) then
89  * the stream is allocated from a pool of per-RC stream indexes,
90  * otherwise a unique stream index for the target is selected.
91  */
92 static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
93 {
94         struct uwb_rc *rc = rsv->rc;
95         unsigned long *streams_bm;
96         int stream;
97
98         switch (rsv->target.type) {
99         case UWB_RSV_TARGET_DEV:
100                 streams_bm = rsv->target.dev->streams;
101                 break;
102         case UWB_RSV_TARGET_DEVADDR:
103                 streams_bm = rc->uwb_dev.streams;
104                 break;
105         default:
106                 return -EINVAL;
107         }
108
109         stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
110         if (stream >= UWB_NUM_STREAMS)
111                 return -EBUSY;
112
113         rsv->stream = stream;
114         set_bit(stream, streams_bm);
115
116         return 0;
117 }
118
119 static void uwb_rsv_put_stream(struct uwb_rsv *rsv)
120 {
121         struct uwb_rc *rc = rsv->rc;
122         unsigned long *streams_bm;
123
124         switch (rsv->target.type) {
125         case UWB_RSV_TARGET_DEV:
126                 streams_bm = rsv->target.dev->streams;
127                 break;
128         case UWB_RSV_TARGET_DEVADDR:
129                 streams_bm = rc->uwb_dev.streams;
130                 break;
131         default:
132                 return;
133         }
134
135         clear_bit(rsv->stream, streams_bm);
136 }
137
138 /*
139  * Generate a MAS allocation with a single row component.
140  */
141 static void uwb_rsv_gen_alloc_row(struct uwb_mas_bm *mas,
142                                   int first_mas, int mas_per_zone,
143                                   int zs, int ze)
144 {
145         struct uwb_mas_bm col;
146         int z;
147
148         bitmap_zero(mas->bm, UWB_NUM_MAS);
149         bitmap_zero(col.bm, UWB_NUM_MAS);
150         bitmap_fill(col.bm, mas_per_zone);
151         bitmap_shift_left(col.bm, col.bm, first_mas + zs * UWB_MAS_PER_ZONE, UWB_NUM_MAS);
152
153         for (z = zs; z <= ze; z++) {
154                 bitmap_or(mas->bm, mas->bm, col.bm, UWB_NUM_MAS);
155                 bitmap_shift_left(col.bm, col.bm, UWB_MAS_PER_ZONE, UWB_NUM_MAS);
156         }
157 }
158
159 /*
160  * Allocate some MAS for this reservation based on current local
161  * availability, the reservation parameters (max_mas, min_mas,
162  * sparsity), and the WiMedia rules for MAS allocations.
163  *
164  * Returns -EBUSY is insufficient free MAS are available.
165  *
166  * FIXME: to simplify this, only safe reservations with a single row
167  * component in zones 1 to 15 are tried (zone 0 is skipped to avoid
168  * problems with the MAS reserved for the BP).
169  *
170  * [ECMA-368] section B.2.
171  */
172 static int uwb_rsv_alloc_mas(struct uwb_rsv *rsv)
173 {
174         static const int safe_mas_in_row[UWB_NUM_ZONES] = {
175                 8, 7, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2, 1,
176         };
177         int n, r;
178         struct uwb_mas_bm mas;
179         bool found = false;
180
181         /*
182          * Search all valid safe allocations until either: too few MAS
183          * are available; or the smallest allocation with sufficient
184          * MAS is found.
185          *
186          * The top of the zones are preferred, so space for larger
187          * allocations is available in the bottom of the zone (e.g., a
188          * 15 MAS allocation should start in row 14 leaving space for
189          * a 120 MAS allocation at row 0).
190          */
191         for (n = safe_mas_in_row[0]; n >= 1; n--) {
192                 int num_mas;
193
194                 num_mas = n * (UWB_NUM_ZONES - 1);
195                 if (num_mas < rsv->min_mas)
196                         break;
197                 if (found && num_mas < rsv->max_mas)
198                         break;
199
200                 for (r = UWB_MAS_PER_ZONE-1;  r >= 0; r--) {
201                         if (safe_mas_in_row[r] < n)
202                                 continue;
203                         uwb_rsv_gen_alloc_row(&mas, r, n, 1, UWB_NUM_ZONES);
204                         if (uwb_drp_avail_reserve_pending(rsv->rc, &mas) == 0) {
205                                 found = true;
206                                 break;
207                         }
208                 }
209         }
210
211         if (!found)
212                 return -EBUSY;
213
214         bitmap_copy(rsv->mas.bm, mas.bm, UWB_NUM_MAS);
215         return 0;
216 }
217
218 static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
219 {
220         int sframes = UWB_MAX_LOST_BEACONS;
221
222         /*
223          * Multicast reservations can become established within 1
224          * super frame and should not be terminated if no response is
225          * received.
226          */
227         if (rsv->is_multicast) {
228                 if (rsv->state == UWB_RSV_STATE_O_INITIATED)
229                         sframes = 1;
230                 if (rsv->state == UWB_RSV_STATE_O_ESTABLISHED)
231                         sframes = 0;
232         }
233
234         rsv->expired = false;
235         if (sframes > 0) {
236                 /*
237                  * Add an additional 2 superframes to account for the
238                  * time to send the SET DRP IE command.
239                  */
240                 unsigned timeout_us = (sframes + 2) * UWB_SUPERFRAME_LENGTH_US;
241                 mod_timer(&rsv->timer, jiffies + usecs_to_jiffies(timeout_us));
242         } else
243                 del_timer(&rsv->timer);
244 }
245
246 /*
247  * Update a reservations state, and schedule an update of the
248  * transmitted DRP IEs.
249  */
250 static void uwb_rsv_state_update(struct uwb_rsv *rsv,
251                                  enum uwb_rsv_state new_state)
252 {
253         rsv->state = new_state;
254         rsv->ie_valid = false;
255
256         uwb_rsv_dump(rsv);
257
258         uwb_rsv_stroke_timer(rsv);
259         uwb_rsv_sched_update(rsv->rc);
260 }
261
262 static void uwb_rsv_callback(struct uwb_rsv *rsv)
263 {
264         if (rsv->callback)
265                 rsv->callback(rsv);
266 }
267
268 void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
269 {
270         if (rsv->state == new_state) {
271                 switch (rsv->state) {
272                 case UWB_RSV_STATE_O_ESTABLISHED:
273                 case UWB_RSV_STATE_T_ACCEPTED:
274                 case UWB_RSV_STATE_NONE:
275                         uwb_rsv_stroke_timer(rsv);
276                         break;
277                 default:
278                         /* Expecting a state transition so leave timer
279                            as-is. */
280                         break;
281                 }
282                 return;
283         }
284
285         switch (new_state) {
286         case UWB_RSV_STATE_NONE:
287                 uwb_drp_avail_release(rsv->rc, &rsv->mas);
288                 uwb_rsv_put_stream(rsv);
289                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
290                 uwb_rsv_callback(rsv);
291                 break;
292         case UWB_RSV_STATE_O_INITIATED:
293                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_INITIATED);
294                 break;
295         case UWB_RSV_STATE_O_PENDING:
296                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_PENDING);
297                 break;
298         case UWB_RSV_STATE_O_ESTABLISHED:
299                 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
300                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_O_ESTABLISHED);
301                 uwb_rsv_callback(rsv);
302                 break;
303         case UWB_RSV_STATE_T_ACCEPTED:
304                 uwb_drp_avail_reserve(rsv->rc, &rsv->mas);
305                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_ACCEPTED);
306                 uwb_rsv_callback(rsv);
307                 break;
308         case UWB_RSV_STATE_T_DENIED:
309                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_T_DENIED);
310                 break;
311         default:
312                 dev_err(&rsv->rc->uwb_dev.dev, "unhandled state: %s (%d)\n",
313                         uwb_rsv_state_str(new_state), new_state);
314         }
315 }
316
317 static struct uwb_rsv *uwb_rsv_alloc(struct uwb_rc *rc)
318 {
319         struct uwb_rsv *rsv;
320
321         rsv = kzalloc(sizeof(struct uwb_rsv), GFP_KERNEL);
322         if (!rsv)
323                 return NULL;
324
325         INIT_LIST_HEAD(&rsv->rc_node);
326         INIT_LIST_HEAD(&rsv->pal_node);
327         init_timer(&rsv->timer);
328         rsv->timer.function = uwb_rsv_timer;
329         rsv->timer.data     = (unsigned long)rsv;
330
331         rsv->rc = rc;
332
333         return rsv;
334 }
335
336 static void uwb_rsv_free(struct uwb_rsv *rsv)
337 {
338         uwb_dev_put(rsv->owner);
339         if (rsv->target.type == UWB_RSV_TARGET_DEV)
340                 uwb_dev_put(rsv->target.dev);
341         kfree(rsv);
342 }
343
344 /**
345  * uwb_rsv_create - allocate and initialize a UWB reservation structure
346  * @rc: the radio controller
347  * @cb: callback to use when the reservation completes or terminates
348  * @pal_priv: data private to the PAL to be passed in the callback
349  *
350  * The callback is called when the state of the reservation changes from:
351  *
352  *   - pending to accepted
353  *   - pending to denined
354  *   - accepted to terminated
355  *   - pending to terminated
356  */
357 struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv)
358 {
359         struct uwb_rsv *rsv;
360
361         rsv = uwb_rsv_alloc(rc);
362         if (!rsv)
363                 return NULL;
364
365         rsv->callback = cb;
366         rsv->pal_priv = pal_priv;
367
368         return rsv;
369 }
370 EXPORT_SYMBOL_GPL(uwb_rsv_create);
371
372 void uwb_rsv_remove(struct uwb_rsv *rsv)
373 {
374         if (rsv->state != UWB_RSV_STATE_NONE)
375                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
376         del_timer_sync(&rsv->timer);
377         list_del(&rsv->rc_node);
378         uwb_rsv_free(rsv);
379 }
380
381 /**
382  * uwb_rsv_destroy - free a UWB reservation structure
383  * @rsv: the reservation to free
384  *
385  * The reservation will be terminated if it is pending or established.
386  */
387 void uwb_rsv_destroy(struct uwb_rsv *rsv)
388 {
389         struct uwb_rc *rc = rsv->rc;
390
391         mutex_lock(&rc->rsvs_mutex);
392         uwb_rsv_remove(rsv);
393         mutex_unlock(&rc->rsvs_mutex);
394 }
395 EXPORT_SYMBOL_GPL(uwb_rsv_destroy);
396
397 /**
398  * usb_rsv_establish - start a reservation establishment
399  * @rsv: the reservation
400  *
401  * The PAL should fill in @rsv's owner, target, type, max_mas,
402  * min_mas, sparsity and is_multicast fields.  If the target is a
403  * uwb_dev it must be referenced.
404  *
405  * The reservation's callback will be called when the reservation is
406  * accepted, denied or times out.
407  */
408 int uwb_rsv_establish(struct uwb_rsv *rsv)
409 {
410         struct uwb_rc *rc = rsv->rc;
411         int ret;
412
413         mutex_lock(&rc->rsvs_mutex);
414
415         ret = uwb_rsv_get_stream(rsv);
416         if (ret)
417                 goto out;
418
419         ret = uwb_rsv_alloc_mas(rsv);
420         if (ret) {
421                 uwb_rsv_put_stream(rsv);
422                 goto out;
423         }
424
425         list_add_tail(&rsv->rc_node, &rc->reservations);
426         rsv->owner = &rc->uwb_dev;
427         uwb_dev_get(rsv->owner);
428         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_INITIATED);
429 out:
430         mutex_unlock(&rc->rsvs_mutex);
431         return ret;
432 }
433 EXPORT_SYMBOL_GPL(uwb_rsv_establish);
434
435 /**
436  * uwb_rsv_modify - modify an already established reservation
437  * @rsv: the reservation to modify
438  * @max_mas: new maximum MAS to reserve
439  * @min_mas: new minimum MAS to reserve
440  * @sparsity: new sparsity to use
441  *
442  * FIXME: implement this once there are PALs that use it.
443  */
444 int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int sparsity)
445 {
446         return -ENOSYS;
447 }
448 EXPORT_SYMBOL_GPL(uwb_rsv_modify);
449
450 /**
451  * uwb_rsv_terminate - terminate an established reservation
452  * @rsv: the reservation to terminate
453  *
454  * A reservation is terminated by removing the DRP IE from the beacon,
455  * the other end will consider the reservation to be terminated when
456  * it does not see the DRP IE for at least mMaxLostBeacons.
457  *
458  * If applicable, the reference to the target uwb_dev will be released.
459  */
460 void uwb_rsv_terminate(struct uwb_rsv *rsv)
461 {
462         struct uwb_rc *rc = rsv->rc;
463
464         mutex_lock(&rc->rsvs_mutex);
465
466         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
467
468         mutex_unlock(&rc->rsvs_mutex);
469 }
470 EXPORT_SYMBOL_GPL(uwb_rsv_terminate);
471
472 /**
473  * uwb_rsv_accept - accept a new reservation from a peer
474  * @rsv:      the reservation
475  * @cb:       call back for reservation changes
476  * @pal_priv: data to be passed in the above call back
477  *
478  * Reservation requests from peers are denied unless a PAL accepts it
479  * by calling this function.
480  */
481 void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv)
482 {
483         rsv->callback = cb;
484         rsv->pal_priv = pal_priv;
485         rsv->state    = UWB_RSV_STATE_T_ACCEPTED;
486 }
487 EXPORT_SYMBOL_GPL(uwb_rsv_accept);
488
489 /*
490  * Is a received DRP IE for this reservation?
491  */
492 static bool uwb_rsv_match(struct uwb_rsv *rsv, struct uwb_dev *src,
493                           struct uwb_ie_drp *drp_ie)
494 {
495         struct uwb_dev_addr *rsv_src;
496         int stream;
497
498         stream = uwb_ie_drp_stream_index(drp_ie);
499
500         if (rsv->stream != stream)
501                 return false;
502
503         switch (rsv->target.type) {
504         case UWB_RSV_TARGET_DEVADDR:
505                 return rsv->stream == stream;
506         case UWB_RSV_TARGET_DEV:
507                 if (uwb_ie_drp_owner(drp_ie))
508                         rsv_src = &rsv->owner->dev_addr;
509                 else
510                         rsv_src = &rsv->target.dev->dev_addr;
511                 return uwb_dev_addr_cmp(&src->dev_addr, rsv_src) == 0;
512         }
513         return false;
514 }
515
516 static struct uwb_rsv *uwb_rsv_new_target(struct uwb_rc *rc,
517                                           struct uwb_dev *src,
518                                           struct uwb_ie_drp *drp_ie)
519 {
520         struct uwb_rsv *rsv;
521         struct uwb_pal *pal;
522         enum uwb_rsv_state state;
523
524         rsv = uwb_rsv_alloc(rc);
525         if (!rsv)
526                 return NULL;
527
528         rsv->rc          = rc;
529         rsv->owner       = src;
530         uwb_dev_get(rsv->owner);
531         rsv->target.type = UWB_RSV_TARGET_DEV;
532         rsv->target.dev  = &rc->uwb_dev;
533         rsv->type        = uwb_ie_drp_type(drp_ie);
534         rsv->stream      = uwb_ie_drp_stream_index(drp_ie);
535         set_bit(rsv->stream, rsv->owner->streams);
536         uwb_drp_ie_to_bm(&rsv->mas, drp_ie);
537
538         /*
539          * See if any PALs are interested in this reservation. If not,
540          * deny the request.
541          */
542         rsv->state = UWB_RSV_STATE_T_DENIED;
543         spin_lock(&rc->pal_lock);
544         list_for_each_entry(pal, &rc->pals, node) {
545                 if (pal->new_rsv)
546                         pal->new_rsv(rsv);
547                 if (rsv->state == UWB_RSV_STATE_T_ACCEPTED)
548                         break;
549         }
550         spin_unlock(&rc->pal_lock);
551
552         list_add_tail(&rsv->rc_node, &rc->reservations);
553         state = rsv->state;
554         rsv->state = UWB_RSV_STATE_NONE;
555         uwb_rsv_set_state(rsv, state);
556
557         return rsv;
558 }
559
560 /**
561  * uwb_rsv_find - find a reservation for a received DRP IE.
562  * @rc: the radio controller
563  * @src: source of the DRP IE
564  * @drp_ie: the DRP IE
565  *
566  * If the reservation cannot be found and the DRP IE is from a peer
567  * attempting to establish a new reservation, create a new reservation
568  * and add it to the list.
569  */
570 struct uwb_rsv *uwb_rsv_find(struct uwb_rc *rc, struct uwb_dev *src,
571                              struct uwb_ie_drp *drp_ie)
572 {
573         struct uwb_rsv *rsv;
574
575         list_for_each_entry(rsv, &rc->reservations, rc_node) {
576                 if (uwb_rsv_match(rsv, src, drp_ie))
577                         return rsv;
578         }
579
580         if (uwb_ie_drp_owner(drp_ie))
581                 return uwb_rsv_new_target(rc, src, drp_ie);
582
583         return NULL;
584 }
585
586 /*
587  * Go through all the reservations and check for timeouts and (if
588  * necessary) update their DRP IEs.
589  *
590  * FIXME: look at building the SET_DRP_IE command here rather than
591  * having to rescan the list in uwb_rc_send_all_drp_ie().
592  */
593 static bool uwb_rsv_update_all(struct uwb_rc *rc)
594 {
595         struct uwb_rsv *rsv, *t;
596         bool ie_updated = false;
597
598         list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
599                 if (rsv->expired)
600                         uwb_drp_handle_timeout(rsv);
601                 if (!rsv->ie_valid) {
602                         uwb_drp_ie_update(rsv);
603                         ie_updated = true;
604                 }
605         }
606
607         return ie_updated;
608 }
609
610 void uwb_rsv_sched_update(struct uwb_rc *rc)
611 {
612         queue_work(rc->rsv_workq, &rc->rsv_update_work);
613 }
614
615 /*
616  * Update DRP IEs and, if necessary, the DRP Availability IE and send
617  * the updated IEs to the radio controller.
618  */
619 static void uwb_rsv_update_work(struct work_struct *work)
620 {
621         struct uwb_rc *rc = container_of(work, struct uwb_rc, rsv_update_work);
622         bool ie_updated;
623
624         mutex_lock(&rc->rsvs_mutex);
625
626         ie_updated = uwb_rsv_update_all(rc);
627
628         if (!rc->drp_avail.ie_valid) {
629                 uwb_drp_avail_ie_update(rc);
630                 ie_updated = true;
631         }
632
633         if (ie_updated)
634                 uwb_rc_send_all_drp_ie(rc);
635
636         mutex_unlock(&rc->rsvs_mutex);
637 }
638
639 static void uwb_rsv_timer(unsigned long arg)
640 {
641         struct uwb_rsv *rsv = (struct uwb_rsv *)arg;
642
643         rsv->expired = true;
644         uwb_rsv_sched_update(rsv->rc);
645 }
646
647 void uwb_rsv_init(struct uwb_rc *rc)
648 {
649         INIT_LIST_HEAD(&rc->reservations);
650         mutex_init(&rc->rsvs_mutex);
651         INIT_WORK(&rc->rsv_update_work, uwb_rsv_update_work);
652
653         bitmap_complement(rc->uwb_dev.streams, rc->uwb_dev.streams, UWB_NUM_STREAMS);
654 }
655
656 int uwb_rsv_setup(struct uwb_rc *rc)
657 {
658         char name[16];
659
660         snprintf(name, sizeof(name), "%s_rsvd", dev_name(&rc->uwb_dev.dev));
661         rc->rsv_workq = create_singlethread_workqueue(name);
662         if (rc->rsv_workq == NULL)
663                 return -ENOMEM;
664
665         return 0;
666 }
667
668 void uwb_rsv_cleanup(struct uwb_rc *rc)
669 {
670         struct uwb_rsv *rsv, *t;
671
672         mutex_lock(&rc->rsvs_mutex);
673         list_for_each_entry_safe(rsv, t, &rc->reservations, rc_node) {
674                 uwb_rsv_remove(rsv);
675         }
676         mutex_unlock(&rc->rsvs_mutex);
677
678         cancel_work_sync(&rc->rsv_update_work);
679         destroy_workqueue(rc->rsv_workq);
680 }