GNU Linux-libre 4.14.290-gnu1
[releases.git] / drivers / uwb / drp.c
1 /*
2  * Ultra Wide Band
3  * Dynamic Reservation Protocol handling
4  *
5  * Copyright (C) 2005-2006 Intel Corporation
6  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
7  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License version
11  * 2 as published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21 #include <linux/kthread.h>
22 #include <linux/freezer.h>
23 #include <linux/slab.h>
24 #include <linux/delay.h>
25 #include "uwb-internal.h"
26
27
28 /* DRP Conflict Actions ([ECMA-368 2nd Edition] 17.4.6) */
29 enum uwb_drp_conflict_action {
30         /* Reservation is maintained, no action needed */
31         UWB_DRP_CONFLICT_MANTAIN = 0,
32
33         /* the device shall not transmit frames in conflicting MASs in
34          * the following superframe. If the device is the reservation
35          * target, it shall also set the Reason Code in its DRP IE to
36          * Conflict in its beacon in the following superframe.
37          */
38         UWB_DRP_CONFLICT_ACT1,
39
40         /* the device shall not set the Reservation Status bit to ONE
41          * and shall not transmit frames in conflicting MASs. If the
42          * device is the reservation target, it shall also set the
43          * Reason Code in its DRP IE to Conflict.
44          */
45         UWB_DRP_CONFLICT_ACT2,
46
47         /* the device shall not transmit frames in conflicting MASs in
48          * the following superframe. It shall remove the conflicting
49          * MASs from the reservation or set the Reservation Status to
50          * ZERO in its beacon in the following superframe. If the
51          * device is the reservation target, it shall also set the
52          * Reason Code in its DRP IE to Conflict.
53          */
54         UWB_DRP_CONFLICT_ACT3,
55 };
56
57
58 static void uwb_rc_set_drp_cmd_done(struct uwb_rc *rc, void *arg,
59                                     struct uwb_rceb *reply, ssize_t reply_size)
60 {
61         struct uwb_rc_evt_set_drp_ie *r = (struct uwb_rc_evt_set_drp_ie *)reply;
62         unsigned long flags;
63
64         if (r != NULL) {
65                 if (r->bResultCode != UWB_RC_RES_SUCCESS)
66                         dev_err(&rc->uwb_dev.dev, "SET-DRP-IE failed: %s (%d)\n",
67                                 uwb_rc_strerror(r->bResultCode), r->bResultCode);
68         } else
69                 dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: timeout\n");
70
71         spin_lock_irqsave(&rc->rsvs_lock, flags);
72         if (rc->set_drp_ie_pending > 1) {
73                 rc->set_drp_ie_pending = 0;
74                 uwb_rsv_queue_update(rc);
75         } else {
76                 rc->set_drp_ie_pending = 0;
77         }
78         spin_unlock_irqrestore(&rc->rsvs_lock, flags);
79 }
80
81 /**
82  * Construct and send the SET DRP IE
83  *
84  * @rc:         UWB Host controller
85  * @returns:    >= 0 number of bytes still available in the beacon
86  *              < 0 errno code on error.
87  *
88  * See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
89  * device to include in its beacon at the same time. We thus have to
90  * traverse all reservations and include the DRP IEs of all PENDING
91  * and NEGOTIATED reservations in a SET DRP command for transmission.
92  *
93  * A DRP Availability IE is appended.
94  *
95  * rc->rsvs_mutex is held
96  *
97  * FIXME We currently ignore the returned value indicating the remaining space
98  * in beacon. This could be used to deny reservation requests earlier if
99  * determined that they would cause the beacon space to be exceeded.
100  */
101 int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
102 {
103         int result;
104         struct uwb_rc_cmd_set_drp_ie *cmd;
105         struct uwb_rsv *rsv;
106         struct uwb_rsv_move *mv;
107         int num_bytes = 0;
108         u8 *IEDataptr;
109
110         result = -ENOMEM;
111         /* First traverse all reservations to determine memory needed. */
112         list_for_each_entry(rsv, &rc->reservations, rc_node) {
113                 if (rsv->drp_ie != NULL) {
114                         num_bytes += rsv->drp_ie->hdr.length + 2;
115                         if (uwb_rsv_has_two_drp_ies(rsv) &&
116                                 (rsv->mv.companion_drp_ie != NULL)) {
117                                 mv = &rsv->mv;
118                                 num_bytes +=
119                                         mv->companion_drp_ie->hdr.length + 2;
120                         }
121                 }
122         }
123         num_bytes += sizeof(rc->drp_avail.ie);
124         cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
125         if (cmd == NULL)
126                 goto error;
127         cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
128         cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
129         cmd->wIELength = num_bytes;
130         IEDataptr = (u8 *)&cmd->IEData[0];
131
132         /* FIXME: DRV avail IE is not always needed */
133         /* put DRP avail IE first */
134         memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));
135         IEDataptr += sizeof(struct uwb_ie_drp_avail);
136
137         /* Next traverse all reservations to place IEs in allocated memory. */
138         list_for_each_entry(rsv, &rc->reservations, rc_node) {
139                 if (rsv->drp_ie != NULL) {
140                         memcpy(IEDataptr, rsv->drp_ie,
141                                rsv->drp_ie->hdr.length + 2);
142                         IEDataptr += rsv->drp_ie->hdr.length + 2;
143
144                         if (uwb_rsv_has_two_drp_ies(rsv) &&
145                                 (rsv->mv.companion_drp_ie != NULL)) {
146                                 mv = &rsv->mv;
147                                 memcpy(IEDataptr, mv->companion_drp_ie,
148                                        mv->companion_drp_ie->hdr.length + 2);
149                                 IEDataptr +=
150                                         mv->companion_drp_ie->hdr.length + 2;
151                         }
152                 }
153         }
154
155         result = uwb_rc_cmd_async(rc, "SET-DRP-IE",
156                                 &cmd->rccb, sizeof(*cmd) + num_bytes,
157                                 UWB_RC_CET_GENERAL, UWB_RC_CMD_SET_DRP_IE,
158                                 uwb_rc_set_drp_cmd_done, NULL);
159
160         rc->set_drp_ie_pending = 1;
161
162         kfree(cmd);
163 error:
164         return result;
165 }
166
167 /*
168  * Evaluate the action to perform using conflict resolution rules
169  *
170  * Return a uwb_drp_conflict_action.
171  */
172 static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beacon_slot,
173                                     struct uwb_rsv *rsv, int our_status)
174 {
175         int our_tie_breaker = rsv->tiebreaker;
176         int our_type        = rsv->type;
177         int our_beacon_slot = rsv->rc->uwb_dev.beacon_slot;
178
179         int ext_tie_breaker = uwb_ie_drp_tiebreaker(ext_drp_ie);
180         int ext_status      = uwb_ie_drp_status(ext_drp_ie);
181         int ext_type        = uwb_ie_drp_type(ext_drp_ie);
182
183
184         /* [ECMA-368 2nd Edition] 17.4.6 */
185         if (ext_type == UWB_DRP_TYPE_PCA && our_type == UWB_DRP_TYPE_PCA) {
186                 return UWB_DRP_CONFLICT_MANTAIN;
187         }
188
189         /* [ECMA-368 2nd Edition] 17.4.6-1 */
190         if (our_type == UWB_DRP_TYPE_ALIEN_BP) {
191                 return UWB_DRP_CONFLICT_MANTAIN;
192         }
193
194         /* [ECMA-368 2nd Edition] 17.4.6-2 */
195         if (ext_type == UWB_DRP_TYPE_ALIEN_BP) {
196                 /* here we know our_type != UWB_DRP_TYPE_ALIEN_BP */
197                 return UWB_DRP_CONFLICT_ACT1;
198         }
199
200         /* [ECMA-368 2nd Edition] 17.4.6-3 */
201         if (our_status == 0 && ext_status == 1) {
202                 return UWB_DRP_CONFLICT_ACT2;
203         }
204
205         /* [ECMA-368 2nd Edition] 17.4.6-4 */
206         if (our_status == 1 && ext_status == 0) {
207                 return UWB_DRP_CONFLICT_MANTAIN;
208         }
209
210         /* [ECMA-368 2nd Edition] 17.4.6-5a */
211         if (our_tie_breaker == ext_tie_breaker &&
212             our_beacon_slot <  ext_beacon_slot) {
213                 return UWB_DRP_CONFLICT_MANTAIN;
214         }
215
216         /* [ECMA-368 2nd Edition] 17.4.6-5b */
217         if (our_tie_breaker != ext_tie_breaker &&
218             our_beacon_slot >  ext_beacon_slot) {
219                 return UWB_DRP_CONFLICT_MANTAIN;
220         }
221
222         if (our_status == 0) {
223                 if (our_tie_breaker == ext_tie_breaker) {
224                         /* [ECMA-368 2nd Edition] 17.4.6-6a */
225                         if (our_beacon_slot > ext_beacon_slot) {
226                                 return UWB_DRP_CONFLICT_ACT2;
227                         }
228                 } else  {
229                         /* [ECMA-368 2nd Edition] 17.4.6-6b */
230                         if (our_beacon_slot < ext_beacon_slot) {
231                                 return UWB_DRP_CONFLICT_ACT2;
232                         }
233                 }
234         } else {
235                 if (our_tie_breaker == ext_tie_breaker) {
236                         /* [ECMA-368 2nd Edition] 17.4.6-7a */
237                         if (our_beacon_slot > ext_beacon_slot) {
238                                 return UWB_DRP_CONFLICT_ACT3;
239                         }
240                 } else {
241                         /* [ECMA-368 2nd Edition] 17.4.6-7b */
242                         if (our_beacon_slot < ext_beacon_slot) {
243                                 return UWB_DRP_CONFLICT_ACT3;
244                         }
245                 }
246         }
247         return UWB_DRP_CONFLICT_MANTAIN;
248 }
249
250 static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
251                                    int ext_beacon_slot,
252                                    struct uwb_rsv *rsv,
253                                    struct uwb_mas_bm *conflicting_mas)
254 {
255         struct uwb_rc *rc = rsv->rc;
256         struct uwb_rsv_move *mv = &rsv->mv;
257         struct uwb_drp_backoff_win *bow = &rc->bow;
258         int action;
259
260         action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, uwb_rsv_status(rsv));
261
262         if (uwb_rsv_is_owner(rsv)) {
263                 switch(action) {
264                 case UWB_DRP_CONFLICT_ACT2:
265                         /* try move */
266                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_TO_BE_MOVED);
267                         if (bow->can_reserve_extra_mases == false)
268                                 uwb_rsv_backoff_win_increment(rc);
269
270                         break;
271                 case UWB_DRP_CONFLICT_ACT3:
272                         uwb_rsv_backoff_win_increment(rc);
273                         /* drop some mases with reason modified */
274                         /* put in the companion the mases to be dropped */
275                         bitmap_and(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
276                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
277                 default:
278                         break;
279                 }
280         } else {
281                 switch(action) {
282                 case UWB_DRP_CONFLICT_ACT2:
283                 case UWB_DRP_CONFLICT_ACT3:
284                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
285                 default:
286                         break;
287                 }
288
289         }
290
291 }
292
293 static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_slot,
294                                       struct uwb_rsv *rsv, bool companion_only,
295                                       struct uwb_mas_bm *conflicting_mas)
296 {
297         struct uwb_rc *rc = rsv->rc;
298         struct uwb_drp_backoff_win *bow = &rc->bow;
299         struct uwb_rsv_move *mv = &rsv->mv;
300         int action;
301
302         if (companion_only) {
303                 /* status of companion is 0 at this point */
304                 action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, 0);
305                 if (uwb_rsv_is_owner(rsv)) {
306                         switch(action) {
307                         case UWB_DRP_CONFLICT_ACT2:
308                         case UWB_DRP_CONFLICT_ACT3:
309                                 uwb_rsv_set_state(rsv,
310                                                 UWB_RSV_STATE_O_ESTABLISHED);
311                                 rsv->needs_release_companion_mas = false;
312                                 if (bow->can_reserve_extra_mases == false)
313                                         uwb_rsv_backoff_win_increment(rc);
314                                 uwb_drp_avail_release(rsv->rc,
315                                                 &rsv->mv.companion_mas);
316                         }
317                 } else { /* rsv is target */
318                         switch(action) {
319                         case UWB_DRP_CONFLICT_ACT2:
320                         case UWB_DRP_CONFLICT_ACT3:
321                                 uwb_rsv_set_state(rsv,
322                                         UWB_RSV_STATE_T_EXPANDING_CONFLICT);
323                                 /* send_drp_avail_ie = true; */
324                         }
325                 }
326         } else { /* also base part of the reservation is conflicting */
327                 if (uwb_rsv_is_owner(rsv)) {
328                         uwb_rsv_backoff_win_increment(rc);
329                         /* remove companion part */
330                         uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
331
332                         /* drop some mases with reason modified */
333
334                         /* put in the companion the mases to be dropped */
335                         bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm,
336                                         conflicting_mas->bm, UWB_NUM_MAS);
337                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
338                 } else { /* it is a target rsv */
339                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
340                         /* send_drp_avail_ie = true; */
341                 }
342         }
343 }
344
345 static void uwb_drp_handle_conflict_rsv(struct uwb_rc *rc, struct uwb_rsv *rsv,
346                                         struct uwb_rc_evt_drp *drp_evt,
347                                         struct uwb_ie_drp *drp_ie,
348                                         struct uwb_mas_bm *conflicting_mas)
349 {
350         struct uwb_rsv_move *mv;
351
352         /* check if the conflicting reservation has two drp_ies */
353         if (uwb_rsv_has_two_drp_ies(rsv)) {
354                 mv = &rsv->mv;
355                 if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm,
356                                                                 UWB_NUM_MAS)) {
357                         handle_conflict_expanding(drp_ie,
358                                                 drp_evt->beacon_slot_number,
359                                                 rsv, false, conflicting_mas);
360                 } else {
361                         if (bitmap_intersects(mv->companion_mas.bm,
362                                         conflicting_mas->bm, UWB_NUM_MAS)) {
363                                 handle_conflict_expanding(
364                                         drp_ie, drp_evt->beacon_slot_number,
365                                         rsv, true, conflicting_mas);
366                         }
367                 }
368         } else if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm,
369                                                         UWB_NUM_MAS)) {
370                 handle_conflict_normal(drp_ie, drp_evt->beacon_slot_number,
371                                         rsv, conflicting_mas);
372         }
373 }
374
375 static void uwb_drp_handle_all_conflict_rsv(struct uwb_rc *rc,
376                                             struct uwb_rc_evt_drp *drp_evt,
377                                             struct uwb_ie_drp *drp_ie,
378                                             struct uwb_mas_bm *conflicting_mas)
379 {
380         struct uwb_rsv *rsv;
381
382         list_for_each_entry(rsv, &rc->reservations, rc_node) {
383                 uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie,
384                                                         conflicting_mas);
385         }
386 }
387
388 static void uwb_drp_process_target_accepted(struct uwb_rc *rc,
389         struct uwb_rsv *rsv, struct uwb_rc_evt_drp *drp_evt,
390         struct uwb_ie_drp *drp_ie, struct uwb_mas_bm *mas)
391 {
392         struct uwb_rsv_move *mv = &rsv->mv;
393         int status;
394
395         status = uwb_ie_drp_status(drp_ie);
396
397         if (rsv->state == UWB_RSV_STATE_T_CONFLICT) {
398                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
399                 return;
400         }
401
402         if (rsv->state == UWB_RSV_STATE_T_EXPANDING_ACCEPTED) {
403                 /* drp_ie is companion */
404                 if (!bitmap_equal(rsv->mas.bm, mas->bm, UWB_NUM_MAS)) {
405                         /* stroke companion */
406                         uwb_rsv_set_state(rsv,
407                                 UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
408                 }
409         } else {
410                 if (!bitmap_equal(rsv->mas.bm, mas->bm, UWB_NUM_MAS)) {
411                         if (uwb_drp_avail_reserve_pending(rc, mas) == -EBUSY) {
412                                 /* FIXME: there is a conflict, find
413                                  * the conflicting reservations and
414                                  * take a sensible action. Consider
415                                  * that in drp_ie there is the
416                                  * "neighbour" */
417                                 uwb_drp_handle_all_conflict_rsv(rc, drp_evt,
418                                                 drp_ie, mas);
419                         } else {
420                                 /* accept the extra reservation */
421                                 bitmap_copy(mv->companion_mas.bm, mas->bm,
422                                                                 UWB_NUM_MAS);
423                                 uwb_rsv_set_state(rsv,
424                                         UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
425                         }
426                 } else {
427                         if (status) {
428                                 uwb_rsv_set_state(rsv,
429                                                 UWB_RSV_STATE_T_ACCEPTED);
430                         }
431                 }
432
433         }
434 }
435
436 /*
437  * Based on the DRP IE, transition a target reservation to a new
438  * state.
439  */
440 static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
441                    struct uwb_ie_drp *drp_ie, struct uwb_rc_evt_drp *drp_evt)
442 {
443         struct device *dev = &rc->uwb_dev.dev;
444         struct uwb_rsv_move *mv = &rsv->mv;
445         int status;
446         enum uwb_drp_reason reason_code;
447         struct uwb_mas_bm mas;
448
449         status = uwb_ie_drp_status(drp_ie);
450         reason_code = uwb_ie_drp_reason_code(drp_ie);
451         uwb_drp_ie_to_bm(&mas, drp_ie);
452
453         switch (reason_code) {
454         case UWB_DRP_REASON_ACCEPTED:
455                 uwb_drp_process_target_accepted(rc, rsv, drp_evt, drp_ie, &mas);
456                 break;
457
458         case UWB_DRP_REASON_MODIFIED:
459                 /* check to see if we have already modified the reservation */
460                 if (bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
461                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
462                         break;
463                 }
464
465                 /* find if the owner wants to expand or reduce */
466                 if (bitmap_subset(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
467                         /* owner is reducing */
468                         bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mas.bm,
469                                 UWB_NUM_MAS);
470                         uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
471                 }
472
473                 bitmap_copy(rsv->mas.bm, mas.bm, UWB_NUM_MAS);
474                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_RESIZED);
475                 break;
476         default:
477                 dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
478                          reason_code, status);
479         }
480 }
481
482 static void uwb_drp_process_owner_accepted(struct uwb_rsv *rsv,
483                                                 struct uwb_mas_bm *mas)
484 {
485         struct uwb_rsv_move *mv = &rsv->mv;
486
487         switch (rsv->state) {
488         case UWB_RSV_STATE_O_PENDING:
489         case UWB_RSV_STATE_O_INITIATED:
490         case UWB_RSV_STATE_O_ESTABLISHED:
491                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
492                 break;
493         case UWB_RSV_STATE_O_MODIFIED:
494                 if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
495                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
496                 else
497                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
498                 break;
499
500         case UWB_RSV_STATE_O_MOVE_REDUCING: /* shouldn' t be a problem */
501                 if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
502                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
503                 else
504                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
505                 break;
506         case UWB_RSV_STATE_O_MOVE_EXPANDING:
507                 if (bitmap_equal(mas->bm, mv->companion_mas.bm, UWB_NUM_MAS)) {
508                         /* Companion reservation accepted */
509                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
510                 } else {
511                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
512                 }
513                 break;
514         case UWB_RSV_STATE_O_MOVE_COMBINING:
515                 if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
516                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
517                 else
518                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
519                 break;
520         default:
521                 break;
522         }
523 }
524 /*
525  * Based on the DRP IE, transition an owner reservation to a new
526  * state.
527  */
528 static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
529                                   struct uwb_dev *src, struct uwb_ie_drp *drp_ie,
530                                   struct uwb_rc_evt_drp *drp_evt)
531 {
532         struct device *dev = &rc->uwb_dev.dev;
533         int status;
534         enum uwb_drp_reason reason_code;
535         struct uwb_mas_bm mas;
536
537         status = uwb_ie_drp_status(drp_ie);
538         reason_code = uwb_ie_drp_reason_code(drp_ie);
539         uwb_drp_ie_to_bm(&mas, drp_ie);
540
541         if (status) {
542                 switch (reason_code) {
543                 case UWB_DRP_REASON_ACCEPTED:
544                         uwb_drp_process_owner_accepted(rsv, &mas);
545                         break;
546                 default:
547                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
548                                  reason_code, status);
549                 }
550         } else {
551                 switch (reason_code) {
552                 case UWB_DRP_REASON_PENDING:
553                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
554                         break;
555                 case UWB_DRP_REASON_DENIED:
556                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
557                         break;
558                 case UWB_DRP_REASON_CONFLICT:
559                         /* resolve the conflict */
560                         bitmap_complement(mas.bm, src->last_availability_bm,
561                                           UWB_NUM_MAS);
562                         uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, &mas);
563                         break;
564                 default:
565                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
566                                  reason_code, status);
567                 }
568         }
569 }
570
571 static void uwb_cnflt_alien_stroke_timer(struct uwb_cnflt_alien *cnflt)
572 {
573         unsigned timeout_us = UWB_MAX_LOST_BEACONS * UWB_SUPERFRAME_LENGTH_US;
574         mod_timer(&cnflt->timer, jiffies + usecs_to_jiffies(timeout_us));
575 }
576
577 static void uwb_cnflt_update_work(struct work_struct *work)
578 {
579         struct uwb_cnflt_alien *cnflt = container_of(work,
580                                                      struct uwb_cnflt_alien,
581                                                      cnflt_update_work);
582         struct uwb_cnflt_alien *c;
583         struct uwb_rc *rc = cnflt->rc;
584
585         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
586
587         mutex_lock(&rc->rsvs_mutex);
588
589         list_del(&cnflt->rc_node);
590
591         /* update rc global conflicting alien bitmap */
592         bitmap_zero(rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
593
594         list_for_each_entry(c, &rc->cnflt_alien_list, rc_node) {
595                 bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm,
596                                                 c->mas.bm, UWB_NUM_MAS);
597         }
598
599         queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work,
600                                         usecs_to_jiffies(delay_us));
601
602         kfree(cnflt);
603         mutex_unlock(&rc->rsvs_mutex);
604 }
605
606 static void uwb_cnflt_timer(unsigned long arg)
607 {
608         struct uwb_cnflt_alien *cnflt = (struct uwb_cnflt_alien *)arg;
609
610         queue_work(cnflt->rc->rsv_workq, &cnflt->cnflt_update_work);
611 }
612
613 /*
614  * We have received an DRP_IE of type Alien BP and we need to make
615  * sure we do not transmit in conflicting MASs.
616  */
617 static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
618 {
619         struct device *dev = &rc->uwb_dev.dev;
620         struct uwb_mas_bm mas;
621         struct uwb_cnflt_alien *cnflt;
622         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
623
624         uwb_drp_ie_to_bm(&mas, drp_ie);
625
626         list_for_each_entry(cnflt, &rc->cnflt_alien_list, rc_node) {
627                 if (bitmap_equal(cnflt->mas.bm, mas.bm, UWB_NUM_MAS)) {
628                         /* Existing alien BP reservation conflicting
629                          * bitmap, just reset the timer */
630                         uwb_cnflt_alien_stroke_timer(cnflt);
631                         return;
632                 }
633         }
634
635         /* New alien BP reservation conflicting bitmap */
636
637         /* alloc and initialize new uwb_cnflt_alien */
638         cnflt = kzalloc(sizeof(struct uwb_cnflt_alien), GFP_KERNEL);
639         if (!cnflt) {
640                 dev_err(dev, "failed to alloc uwb_cnflt_alien struct\n");
641                 return;
642         }
643
644         INIT_LIST_HEAD(&cnflt->rc_node);
645         setup_timer(&cnflt->timer, uwb_cnflt_timer, (unsigned long)cnflt);
646
647         cnflt->rc = rc;
648         INIT_WORK(&cnflt->cnflt_update_work, uwb_cnflt_update_work);
649
650         bitmap_copy(cnflt->mas.bm, mas.bm, UWB_NUM_MAS);
651
652         list_add_tail(&cnflt->rc_node, &rc->cnflt_alien_list);
653
654         /* update rc global conflicting alien bitmap */
655         bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, mas.bm, UWB_NUM_MAS);
656
657         queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
658
659         /* start the timer */
660         uwb_cnflt_alien_stroke_timer(cnflt);
661 }
662
663 static void uwb_drp_process_not_involved(struct uwb_rc *rc,
664                                          struct uwb_rc_evt_drp *drp_evt,
665                                          struct uwb_ie_drp *drp_ie)
666 {
667         struct uwb_mas_bm mas;
668
669         uwb_drp_ie_to_bm(&mas, drp_ie);
670         uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
671 }
672
673 static void uwb_drp_process_involved(struct uwb_rc *rc, struct uwb_dev *src,
674                                      struct uwb_rc_evt_drp *drp_evt,
675                                      struct uwb_ie_drp *drp_ie)
676 {
677         struct uwb_rsv *rsv;
678
679         rsv = uwb_rsv_find(rc, src, drp_ie);
680         if (!rsv) {
681                 /*
682                  * No reservation? It's either for a recently
683                  * terminated reservation; or the DRP IE couldn't be
684                  * processed (e.g., an invalid IE or out of memory).
685                  */
686                 return;
687         }
688
689         /*
690          * Do nothing with DRP IEs for reservations that have been
691          * terminated.
692          */
693         if (rsv->state == UWB_RSV_STATE_NONE) {
694                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
695                 return;
696         }
697
698         if (uwb_ie_drp_owner(drp_ie))
699                 uwb_drp_process_target(rc, rsv, drp_ie, drp_evt);
700         else
701                 uwb_drp_process_owner(rc, rsv, src, drp_ie, drp_evt);
702
703 }
704
705
706 static bool uwb_drp_involves_us(struct uwb_rc *rc, struct uwb_ie_drp *drp_ie)
707 {
708         return uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, &drp_ie->dev_addr) == 0;
709 }
710
711 /*
712  * Process a received DRP IE.
713  */
714 static void uwb_drp_process(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
715                             struct uwb_dev *src, struct uwb_ie_drp *drp_ie)
716 {
717         if (uwb_ie_drp_type(drp_ie) == UWB_DRP_TYPE_ALIEN_BP)
718                 uwb_drp_handle_alien_drp(rc, drp_ie);
719         else if (uwb_drp_involves_us(rc, drp_ie))
720                 uwb_drp_process_involved(rc, src, drp_evt, drp_ie);
721         else
722                 uwb_drp_process_not_involved(rc, drp_evt, drp_ie);
723 }
724
725 /*
726  * Process a received DRP Availability IE
727  */
728 static void uwb_drp_availability_process(struct uwb_rc *rc, struct uwb_dev *src,
729                                          struct uwb_ie_drp_avail *drp_availability_ie)
730 {
731         bitmap_copy(src->last_availability_bm,
732                     drp_availability_ie->bmp, UWB_NUM_MAS);
733 }
734
735 /*
736  * Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
737  * from a device.
738  */
739 static
740 void uwb_drp_process_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
741                          size_t ielen, struct uwb_dev *src_dev)
742 {
743         struct device *dev = &rc->uwb_dev.dev;
744         struct uwb_ie_hdr *ie_hdr;
745         void *ptr;
746
747         ptr = drp_evt->ie_data;
748         for (;;) {
749                 ie_hdr = uwb_ie_next(&ptr, &ielen);
750                 if (!ie_hdr)
751                         break;
752
753                 switch (ie_hdr->element_id) {
754                 case UWB_IE_DRP_AVAILABILITY:
755                         uwb_drp_availability_process(rc, src_dev, (struct uwb_ie_drp_avail *)ie_hdr);
756                         break;
757                 case UWB_IE_DRP:
758                         uwb_drp_process(rc, drp_evt, src_dev, (struct uwb_ie_drp *)ie_hdr);
759                         break;
760                 default:
761                         dev_warn(dev, "unexpected IE in DRP notification\n");
762                         break;
763                 }
764         }
765
766         if (ielen > 0)
767                 dev_warn(dev, "%d octets remaining in DRP notification\n",
768                          (int)ielen);
769 }
770
771 /**
772  * uwbd_evt_handle_rc_drp - handle a DRP_IE event
773  * @evt: the DRP_IE event from the radio controller
774  *
775  * This processes DRP notifications from the radio controller, either
776  * initiating a new reservation or transitioning an existing
777  * reservation into a different state.
778  *
779  * DRP notifications can occur for three different reasons:
780  *
781  * - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
782  *   the target or source have been received.
783  *
784  *   These DRP IEs could be new or for an existing reservation.
785  *
786  *   If the DRP IE for an existing reservation ceases to be to
787  *   received for at least mMaxLostBeacons, the reservation should be
788  *   considered to be terminated.  Note that the TERMINATE reason (see
789  *   below) may not always be signalled (e.g., the remote device has
790  *   two or more reservations established with the RC).
791  *
792  * - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
793  *   group conflict with the RC's reservations.
794  *
795  * - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
796  *   from a device (i.e., it's terminated all reservations).
797  *
798  * Only the software state of the reservations is changed; the setting
799  * of the radio controller's DRP IEs is done after all the events in
800  * an event buffer are processed.  This saves waiting multiple times
801  * for the SET_DRP_IE command to complete.
802  */
803 int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
804 {
805         struct device *dev = &evt->rc->uwb_dev.dev;
806         struct uwb_rc *rc = evt->rc;
807         struct uwb_rc_evt_drp *drp_evt;
808         size_t ielength, bytes_left;
809         struct uwb_dev_addr src_addr;
810         struct uwb_dev *src_dev;
811
812         /* Is there enough data to decode the event (and any IEs in
813            its payload)? */
814         if (evt->notif.size < sizeof(*drp_evt)) {
815                 dev_err(dev, "DRP event: Not enough data to decode event "
816                         "[%zu bytes left, %zu needed]\n",
817                         evt->notif.size, sizeof(*drp_evt));
818                 return 0;
819         }
820         bytes_left = evt->notif.size - sizeof(*drp_evt);
821         drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
822         ielength = le16_to_cpu(drp_evt->ie_length);
823         if (bytes_left != ielength) {
824                 dev_err(dev, "DRP event: Not enough data in payload [%zu"
825                         "bytes left, %zu declared in the event]\n",
826                         bytes_left, ielength);
827                 return 0;
828         }
829
830         memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
831         src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
832         if (!src_dev) {
833                 /*
834                  * A DRP notification from an unrecognized device.
835                  *
836                  * This is probably from a WUSB device that doesn't
837                  * have an EUI-48 and therefore doesn't show up in the
838                  * UWB device database.  It's safe to simply ignore
839                  * these.
840                  */
841                 return 0;
842         }
843
844         mutex_lock(&rc->rsvs_mutex);
845
846         /* We do not distinguish from the reason */
847         uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
848
849         mutex_unlock(&rc->rsvs_mutex);
850
851         uwb_dev_put(src_dev);
852         return 0;
853 }