1 /*
2 * UWB DRP IE management.
3 *
4 * Copyright (C) 2005-2006 Intel Corporation
5 * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19 #include <linux/kernel.h>
20 #include <linux/random.h>
21 #include <linux/slab.h>
22 #include <linux/uwb.h>
23
24 #include "uwb-internal.h"
25
26
27 /*
28 * Return the reason code for a reservations's DRP IE.
29 */
uwb_rsv_reason_code(struct uwb_rsv * rsv)30 static int uwb_rsv_reason_code(struct uwb_rsv *rsv)
31 {
32 static const int reason_codes[] = {
33 [UWB_RSV_STATE_O_INITIATED] = UWB_DRP_REASON_ACCEPTED,
34 [UWB_RSV_STATE_O_PENDING] = UWB_DRP_REASON_ACCEPTED,
35 [UWB_RSV_STATE_O_MODIFIED] = UWB_DRP_REASON_MODIFIED,
36 [UWB_RSV_STATE_O_ESTABLISHED] = UWB_DRP_REASON_ACCEPTED,
37 [UWB_RSV_STATE_O_TO_BE_MOVED] = UWB_DRP_REASON_ACCEPTED,
38 [UWB_RSV_STATE_O_MOVE_COMBINING] = UWB_DRP_REASON_MODIFIED,
39 [UWB_RSV_STATE_O_MOVE_REDUCING] = UWB_DRP_REASON_MODIFIED,
40 [UWB_RSV_STATE_O_MOVE_EXPANDING] = UWB_DRP_REASON_ACCEPTED,
41 [UWB_RSV_STATE_T_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
42 [UWB_RSV_STATE_T_CONFLICT] = UWB_DRP_REASON_CONFLICT,
43 [UWB_RSV_STATE_T_PENDING] = UWB_DRP_REASON_PENDING,
44 [UWB_RSV_STATE_T_DENIED] = UWB_DRP_REASON_DENIED,
45 [UWB_RSV_STATE_T_RESIZED] = UWB_DRP_REASON_ACCEPTED,
46 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
47 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = UWB_DRP_REASON_CONFLICT,
48 [UWB_RSV_STATE_T_EXPANDING_PENDING] = UWB_DRP_REASON_PENDING,
49 [UWB_RSV_STATE_T_EXPANDING_DENIED] = UWB_DRP_REASON_DENIED,
50 };
51
52 return reason_codes[rsv->state];
53 }
54
55 /*
56 * Return the reason code for a reservations's companion DRP IE .
57 */
uwb_rsv_companion_reason_code(struct uwb_rsv * rsv)58 static int uwb_rsv_companion_reason_code(struct uwb_rsv *rsv)
59 {
60 static const int companion_reason_codes[] = {
61 [UWB_RSV_STATE_O_MOVE_EXPANDING] = UWB_DRP_REASON_ACCEPTED,
62 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = UWB_DRP_REASON_ACCEPTED,
63 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = UWB_DRP_REASON_CONFLICT,
64 [UWB_RSV_STATE_T_EXPANDING_PENDING] = UWB_DRP_REASON_PENDING,
65 [UWB_RSV_STATE_T_EXPANDING_DENIED] = UWB_DRP_REASON_DENIED,
66 };
67
68 return companion_reason_codes[rsv->state];
69 }
70
71 /*
72 * Return the status bit for a reservations's DRP IE.
73 */
uwb_rsv_status(struct uwb_rsv * rsv)74 int uwb_rsv_status(struct uwb_rsv *rsv)
75 {
76 static const int statuses[] = {
77 [UWB_RSV_STATE_O_INITIATED] = 0,
78 [UWB_RSV_STATE_O_PENDING] = 0,
79 [UWB_RSV_STATE_O_MODIFIED] = 1,
80 [UWB_RSV_STATE_O_ESTABLISHED] = 1,
81 [UWB_RSV_STATE_O_TO_BE_MOVED] = 0,
82 [UWB_RSV_STATE_O_MOVE_COMBINING] = 1,
83 [UWB_RSV_STATE_O_MOVE_REDUCING] = 1,
84 [UWB_RSV_STATE_O_MOVE_EXPANDING] = 1,
85 [UWB_RSV_STATE_T_ACCEPTED] = 1,
86 [UWB_RSV_STATE_T_CONFLICT] = 0,
87 [UWB_RSV_STATE_T_PENDING] = 0,
88 [UWB_RSV_STATE_T_DENIED] = 0,
89 [UWB_RSV_STATE_T_RESIZED] = 1,
90 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = 1,
91 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = 1,
92 [UWB_RSV_STATE_T_EXPANDING_PENDING] = 1,
93 [UWB_RSV_STATE_T_EXPANDING_DENIED] = 1,
94
95 };
96
97 return statuses[rsv->state];
98 }
99
100 /*
101 * Return the status bit for a reservations's companion DRP IE .
102 */
uwb_rsv_companion_status(struct uwb_rsv * rsv)103 int uwb_rsv_companion_status(struct uwb_rsv *rsv)
104 {
105 static const int companion_statuses[] = {
106 [UWB_RSV_STATE_O_MOVE_EXPANDING] = 0,
107 [UWB_RSV_STATE_T_EXPANDING_ACCEPTED] = 1,
108 [UWB_RSV_STATE_T_EXPANDING_CONFLICT] = 0,
109 [UWB_RSV_STATE_T_EXPANDING_PENDING] = 0,
110 [UWB_RSV_STATE_T_EXPANDING_DENIED] = 0,
111 };
112
113 return companion_statuses[rsv->state];
114 }
115
116 /*
117 * Allocate a DRP IE.
118 *
119 * To save having to free/allocate a DRP IE when its MAS changes,
120 * enough memory is allocated for the maxiumum number of DRP
121 * allocation fields. This gives an overhead per reservation of up to
122 * (UWB_NUM_ZONES - 1) * 4 = 60 octets.
123 */
uwb_drp_ie_alloc(void)124 static struct uwb_ie_drp *uwb_drp_ie_alloc(void)
125 {
126 struct uwb_ie_drp *drp_ie;
127
128 drp_ie = kzalloc(sizeof(struct uwb_ie_drp) +
129 UWB_NUM_ZONES * sizeof(struct uwb_drp_alloc),
130 GFP_KERNEL);
131 if (drp_ie)
132 drp_ie->hdr.element_id = UWB_IE_DRP;
133 return drp_ie;
134 }
135
136
137 /*
138 * Fill a DRP IE's allocation fields from a MAS bitmap.
139 */
uwb_drp_ie_from_bm(struct uwb_ie_drp * drp_ie,struct uwb_mas_bm * mas)140 static void uwb_drp_ie_from_bm(struct uwb_ie_drp *drp_ie,
141 struct uwb_mas_bm *mas)
142 {
143 int z, i, num_fields = 0, next = 0;
144 struct uwb_drp_alloc *zones;
145 __le16 current_bmp;
146 DECLARE_BITMAP(tmp_bmp, UWB_NUM_MAS);
147 DECLARE_BITMAP(tmp_mas_bm, UWB_MAS_PER_ZONE);
148
149 zones = drp_ie->allocs;
150
151 bitmap_copy(tmp_bmp, mas->bm, UWB_NUM_MAS);
152
153 /* Determine unique MAS bitmaps in zones from bitmap. */
154 for (z = 0; z < UWB_NUM_ZONES; z++) {
155 bitmap_copy(tmp_mas_bm, tmp_bmp, UWB_MAS_PER_ZONE);
156 if (bitmap_weight(tmp_mas_bm, UWB_MAS_PER_ZONE) > 0) {
157 bool found = false;
158 current_bmp = (__le16) *tmp_mas_bm;
159 for (i = 0; i < next; i++) {
160 if (current_bmp == zones[i].mas_bm) {
161 zones[i].zone_bm |= 1 << z;
162 found = true;
163 break;
164 }
165 }
166 if (!found) {
167 num_fields++;
168 zones[next].zone_bm = 1 << z;
169 zones[next].mas_bm = current_bmp;
170 next++;
171 }
172 }
173 bitmap_shift_right(tmp_bmp, tmp_bmp, UWB_MAS_PER_ZONE, UWB_NUM_MAS);
174 }
175
176 /* Store in format ready for transmission (le16). */
177 for (i = 0; i < num_fields; i++) {
178 drp_ie->allocs[i].zone_bm = cpu_to_le16(zones[i].zone_bm);
179 drp_ie->allocs[i].mas_bm = cpu_to_le16(zones[i].mas_bm);
180 }
181
182 drp_ie->hdr.length = sizeof(struct uwb_ie_drp) - sizeof(struct uwb_ie_hdr)
183 + num_fields * sizeof(struct uwb_drp_alloc);
184 }
185
186 /**
187 * uwb_drp_ie_update - update a reservation's DRP IE
188 * @rsv: the reservation
189 */
uwb_drp_ie_update(struct uwb_rsv * rsv)190 int uwb_drp_ie_update(struct uwb_rsv *rsv)
191 {
192 struct uwb_ie_drp *drp_ie;
193 struct uwb_rsv_move *mv;
194 int unsafe;
195
196 if (rsv->state == UWB_RSV_STATE_NONE) {
197 kfree(rsv->drp_ie);
198 rsv->drp_ie = NULL;
199 return 0;
200 }
201
202 unsafe = rsv->mas.unsafe ? 1 : 0;
203
204 if (rsv->drp_ie == NULL) {
205 rsv->drp_ie = uwb_drp_ie_alloc();
206 if (rsv->drp_ie == NULL)
207 return -ENOMEM;
208 }
209 drp_ie = rsv->drp_ie;
210
211 uwb_ie_drp_set_unsafe(drp_ie, unsafe);
212 uwb_ie_drp_set_tiebreaker(drp_ie, rsv->tiebreaker);
213 uwb_ie_drp_set_owner(drp_ie, uwb_rsv_is_owner(rsv));
214 uwb_ie_drp_set_status(drp_ie, uwb_rsv_status(rsv));
215 uwb_ie_drp_set_reason_code(drp_ie, uwb_rsv_reason_code(rsv));
216 uwb_ie_drp_set_stream_index(drp_ie, rsv->stream);
217 uwb_ie_drp_set_type(drp_ie, rsv->type);
218
219 if (uwb_rsv_is_owner(rsv)) {
220 switch (rsv->target.type) {
221 case UWB_RSV_TARGET_DEV:
222 drp_ie->dev_addr = rsv->target.dev->dev_addr;
223 break;
224 case UWB_RSV_TARGET_DEVADDR:
225 drp_ie->dev_addr = rsv->target.devaddr;
226 break;
227 }
228 } else
229 drp_ie->dev_addr = rsv->owner->dev_addr;
230
231 uwb_drp_ie_from_bm(drp_ie, &rsv->mas);
232
233 if (uwb_rsv_has_two_drp_ies(rsv)) {
234 mv = &rsv->mv;
235 if (mv->companion_drp_ie == NULL) {
236 mv->companion_drp_ie = uwb_drp_ie_alloc();
237 if (mv->companion_drp_ie == NULL)
238 return -ENOMEM;
239 }
240 drp_ie = mv->companion_drp_ie;
241
242 /* keep all the same configuration of the main drp_ie */
243 memcpy(drp_ie, rsv->drp_ie, sizeof(struct uwb_ie_drp));
244
245
246 /* FIXME: handle properly the unsafe bit */
247 uwb_ie_drp_set_unsafe(drp_ie, 1);
248 uwb_ie_drp_set_status(drp_ie, uwb_rsv_companion_status(rsv));
249 uwb_ie_drp_set_reason_code(drp_ie, uwb_rsv_companion_reason_code(rsv));
250
251 uwb_drp_ie_from_bm(drp_ie, &mv->companion_mas);
252 }
253
254 rsv->ie_valid = true;
255 return 0;
256 }
257
258 /*
259 * Set MAS bits from given MAS bitmap in a single zone of large bitmap.
260 *
261 * We are given a zone id and the MAS bitmap of bits that need to be set in
262 * this zone. Note that this zone may already have bits set and this only
263 * adds settings - we cannot simply assign the MAS bitmap contents to the
264 * zone contents. We iterate over the the bits (MAS) in the zone and set the
265 * bits that are set in the given MAS bitmap.
266 */
267 static
uwb_drp_ie_single_zone_to_bm(struct uwb_mas_bm * bm,u8 zone,u16 mas_bm)268 void uwb_drp_ie_single_zone_to_bm(struct uwb_mas_bm *bm, u8 zone, u16 mas_bm)
269 {
270 int mas;
271 u16 mas_mask;
272
273 for (mas = 0; mas < UWB_MAS_PER_ZONE; mas++) {
274 mas_mask = 1 << mas;
275 if (mas_bm & mas_mask)
276 set_bit(zone * UWB_NUM_ZONES + mas, bm->bm);
277 }
278 }
279
280 /**
281 * uwb_drp_ie_zones_to_bm - convert DRP allocation fields to a bitmap
282 * @mas: MAS bitmap that will be populated to correspond to the
283 * allocation fields in the DRP IE
284 * @drp_ie: the DRP IE that contains the allocation fields.
285 *
286 * The input format is an array of MAS allocation fields (16 bit Zone
287 * bitmap, 16 bit MAS bitmap) as described in [ECMA-368] section
288 * 16.8.6. The output is a full 256 bit MAS bitmap.
289 *
290 * We go over all the allocation fields, for each allocation field we
291 * know which zones are impacted. We iterate over all the zones
292 * impacted and call a function that will set the correct MAS bits in
293 * each zone.
294 */
uwb_drp_ie_to_bm(struct uwb_mas_bm * bm,const struct uwb_ie_drp * drp_ie)295 void uwb_drp_ie_to_bm(struct uwb_mas_bm *bm, const struct uwb_ie_drp *drp_ie)
296 {
297 int numallocs = (drp_ie->hdr.length - 4) / 4;
298 const struct uwb_drp_alloc *alloc;
299 int cnt;
300 u16 zone_bm, mas_bm;
301 u8 zone;
302 u16 zone_mask;
303
304 bitmap_zero(bm->bm, UWB_NUM_MAS);
305
306 for (cnt = 0; cnt < numallocs; cnt++) {
307 alloc = &drp_ie->allocs[cnt];
308 zone_bm = le16_to_cpu(alloc->zone_bm);
309 mas_bm = le16_to_cpu(alloc->mas_bm);
310 for (zone = 0; zone < UWB_NUM_ZONES; zone++) {
311 zone_mask = 1 << zone;
312 if (zone_bm & zone_mask)
313 uwb_drp_ie_single_zone_to_bm(bm, zone, mas_bm);
314 }
315 }
316 }
317
318