uwb: add the UWB stack (reservation manager)
[linux-2.6.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/delay.h>
24 #include "uwb-internal.h"
25
26 /**
27  * Construct and send the SET DRP IE
28  *
29  * @rc:         UWB Host controller
30  * @returns:    >= 0 number of bytes still available in the beacon
31  *              < 0 errno code on error.
32  *
33  * See WUSB[8.6.2.7]: The host must set all the DRP IEs that it wants the
34  * device to include in its beacon at the same time. We thus have to
35  * traverse all reservations and include the DRP IEs of all PENDING
36  * and NEGOTIATED reservations in a SET DRP command for transmission.
37  *
38  * A DRP Availability IE is appended.
39  *
40  * rc->uwb_dev.mutex is held
41  *
42  * FIXME We currently ignore the returned value indicating the remaining space
43  * in beacon. This could be used to deny reservation requests earlier if
44  * determined that they would cause the beacon space to be exceeded.
45  */
46 static
47 int uwb_rc_gen_send_drp_ie(struct uwb_rc *rc)
48 {
49         int result;
50         struct device *dev = &rc->uwb_dev.dev;
51         struct uwb_rc_cmd_set_drp_ie *cmd;
52         struct uwb_rc_evt_set_drp_ie reply;
53         struct uwb_rsv *rsv;
54         int num_bytes = 0;
55         u8 *IEDataptr;
56
57         result = -ENOMEM;
58         /* First traverse all reservations to determine memory needed. */
59         list_for_each_entry(rsv, &rc->reservations, rc_node) {
60                 if (rsv->drp_ie != NULL)
61                         num_bytes += rsv->drp_ie->hdr.length + 2;
62         }
63         num_bytes += sizeof(rc->drp_avail.ie);
64         cmd = kzalloc(sizeof(*cmd) + num_bytes, GFP_KERNEL);
65         if (cmd == NULL)
66                 goto error;
67         cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
68         cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_SET_DRP_IE);
69         cmd->wIELength = num_bytes;
70         IEDataptr = (u8 *)&cmd->IEData[0];
71
72         /* Next traverse all reservations to place IEs in allocated memory. */
73         list_for_each_entry(rsv, &rc->reservations, rc_node) {
74                 if (rsv->drp_ie != NULL) {
75                         memcpy(IEDataptr, rsv->drp_ie,
76                                rsv->drp_ie->hdr.length + 2);
77                         IEDataptr += rsv->drp_ie->hdr.length + 2;
78                 }
79         }
80         memcpy(IEDataptr, &rc->drp_avail.ie, sizeof(rc->drp_avail.ie));
81
82         reply.rceb.bEventType = UWB_RC_CET_GENERAL;
83         reply.rceb.wEvent = UWB_RC_CMD_SET_DRP_IE;
84         result = uwb_rc_cmd(rc, "SET-DRP-IE", &cmd->rccb,
85                         sizeof(*cmd) + num_bytes, &reply.rceb,
86                         sizeof(reply));
87         if (result < 0)
88                 goto error_cmd;
89         result = le16_to_cpu(reply.wRemainingSpace);
90         if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
91                 dev_err(&rc->uwb_dev.dev, "SET-DRP-IE: command execution "
92                                 "failed: %s (%d). RemainingSpace in beacon "
93                                 "= %d\n", uwb_rc_strerror(reply.bResultCode),
94                                 reply.bResultCode, result);
95                 result = -EIO;
96         } else {
97                 dev_dbg(dev, "SET-DRP-IE sent. RemainingSpace in beacon "
98                              "= %d.\n", result);
99                 result = 0;
100         }
101 error_cmd:
102         kfree(cmd);
103 error:
104         return result;
105
106 }
107 /**
108  * Send all DRP IEs associated with this host
109  *
110  * @returns:    >= 0 number of bytes still available in the beacon
111  *              < 0 errno code on error.
112  *
113  * As per the protocol we obtain the host controller device lock to access
114  * bandwidth structures.
115  */
116 int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
117 {
118         int result;
119
120         mutex_lock(&rc->uwb_dev.mutex);
121         result = uwb_rc_gen_send_drp_ie(rc);
122         mutex_unlock(&rc->uwb_dev.mutex);
123         return result;
124 }
125
126 void uwb_drp_handle_timeout(struct uwb_rsv *rsv)
127 {
128         struct device *dev = &rsv->rc->uwb_dev.dev;
129
130         dev_dbg(dev, "reservation timeout in state %s (%d)\n",
131                 uwb_rsv_state_str(rsv->state), rsv->state);
132
133         switch (rsv->state) {
134         case UWB_RSV_STATE_O_INITIATED:
135                 if (rsv->is_multicast) {
136                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
137                         return;
138                 }
139                 break;
140         case UWB_RSV_STATE_O_ESTABLISHED:
141                 if (rsv->is_multicast)
142                         return;
143                 break;
144         default:
145                 break;
146         }
147         uwb_rsv_remove(rsv);
148 }
149
150 /*
151  * Based on the DRP IE, transition a target reservation to a new
152  * state.
153  */
154 static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
155                                    struct uwb_ie_drp *drp_ie)
156 {
157         struct device *dev = &rc->uwb_dev.dev;
158         int status;
159         enum uwb_drp_reason reason_code;
160
161         status = uwb_ie_drp_status(drp_ie);
162         reason_code = uwb_ie_drp_reason_code(drp_ie);
163
164         if (status) {
165                 switch (reason_code) {
166                 case UWB_DRP_REASON_ACCEPTED:
167                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
168                         break;
169                 case UWB_DRP_REASON_MODIFIED:
170                         dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
171                                 reason_code, status);
172                         break;
173                 default:
174                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
175                                  reason_code, status);
176                 }
177         } else {
178                 switch (reason_code) {
179                 case UWB_DRP_REASON_ACCEPTED:
180                         /* New reservations are handled in uwb_rsv_find(). */
181                         break;
182                 case UWB_DRP_REASON_DENIED:
183                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
184                         break;
185                 case UWB_DRP_REASON_CONFLICT:
186                 case UWB_DRP_REASON_MODIFIED:
187                         dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
188                                 reason_code, status);
189                         break;
190                 default:
191                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
192                                  reason_code, status);
193                 }
194         }
195 }
196
197 /*
198  * Based on the DRP IE, transition an owner reservation to a new
199  * state.
200  */
201 static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
202                                   struct uwb_ie_drp *drp_ie)
203 {
204         struct device *dev = &rc->uwb_dev.dev;
205         int status;
206         enum uwb_drp_reason reason_code;
207
208         status = uwb_ie_drp_status(drp_ie);
209         reason_code = uwb_ie_drp_reason_code(drp_ie);
210
211         if (status) {
212                 switch (reason_code) {
213                 case UWB_DRP_REASON_ACCEPTED:
214                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
215                         break;
216                 case UWB_DRP_REASON_MODIFIED:
217                         dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
218                                 reason_code, status);
219                         break;
220                 default:
221                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
222                                  reason_code, status);
223                 }
224         } else {
225                 switch (reason_code) {
226                 case UWB_DRP_REASON_PENDING:
227                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_PENDING);
228                         break;
229                 case UWB_DRP_REASON_DENIED:
230                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
231                         break;
232                 case UWB_DRP_REASON_CONFLICT:
233                 case UWB_DRP_REASON_MODIFIED:
234                         dev_err(dev, "FIXME: unhandled reason code (%d/%d)\n",
235                                 reason_code, status);
236                         break;
237                 default:
238                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
239                                  reason_code, status);
240                 }
241         }
242 }
243
244 /*
245  * Process a received DRP IE, it's either for a reservation owned by
246  * the RC or targeted at it (or it's for a WUSB cluster reservation).
247  */
248 static void uwb_drp_process(struct uwb_rc *rc, struct uwb_dev *src,
249                      struct uwb_ie_drp *drp_ie)
250 {
251         struct uwb_rsv *rsv;
252
253         rsv = uwb_rsv_find(rc, src, drp_ie);
254         if (!rsv) {
255                 /*
256                  * No reservation? It's either for a recently
257                  * terminated reservation; or the DRP IE couldn't be
258                  * processed (e.g., an invalid IE or out of memory).
259                  */
260                 return;
261         }
262
263         /*
264          * Do nothing with DRP IEs for reservations that have been
265          * terminated.
266          */
267         if (rsv->state == UWB_RSV_STATE_NONE) {
268                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
269                 return;
270         }
271
272         if (uwb_ie_drp_owner(drp_ie))
273                 uwb_drp_process_target(rc, rsv, drp_ie);
274         else
275                 uwb_drp_process_owner(rc, rsv, drp_ie);
276 }
277
278
279 /*
280  * Process all the DRP IEs (both DRP IEs and the DRP Availability IE)
281  * from a device.
282  */
283 static
284 void uwb_drp_process_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
285                          size_t ielen, struct uwb_dev *src_dev)
286 {
287         struct device *dev = &rc->uwb_dev.dev;
288         struct uwb_ie_hdr *ie_hdr;
289         void *ptr;
290
291         ptr = drp_evt->ie_data;
292         for (;;) {
293                 ie_hdr = uwb_ie_next(&ptr, &ielen);
294                 if (!ie_hdr)
295                         break;
296
297                 switch (ie_hdr->element_id) {
298                 case UWB_IE_DRP_AVAILABILITY:
299                         /* FIXME: does something need to be done with this? */
300                         break;
301                 case UWB_IE_DRP:
302                         uwb_drp_process(rc, src_dev, (struct uwb_ie_drp *)ie_hdr);
303                         break;
304                 default:
305                         dev_warn(dev, "unexpected IE in DRP notification\n");
306                         break;
307                 }
308         }
309
310         if (ielen > 0)
311                 dev_warn(dev, "%d octets remaining in DRP notification\n",
312                          (int)ielen);
313 }
314
315
316 /*
317  * Go through all the DRP IEs and find the ones that conflict with our
318  * reservations.
319  *
320  * FIXME: must resolve the conflict according the the rules in
321  * [ECMA-368].
322  */
323 static
324 void uwb_drp_process_conflict_all(struct uwb_rc *rc, struct uwb_rc_evt_drp *drp_evt,
325                                   size_t ielen, struct uwb_dev *src_dev)
326 {
327         struct device *dev = &rc->uwb_dev.dev;
328         struct uwb_ie_hdr *ie_hdr;
329         struct uwb_ie_drp *drp_ie;
330         void *ptr;
331
332         ptr = drp_evt->ie_data;
333         for (;;) {
334                 ie_hdr = uwb_ie_next(&ptr, &ielen);
335                 if (!ie_hdr)
336                         break;
337
338                 drp_ie = container_of(ie_hdr, struct uwb_ie_drp, hdr);
339
340                 /* FIXME: check if this DRP IE conflicts. */
341         }
342
343         if (ielen > 0)
344                 dev_warn(dev, "%d octets remaining in DRP notification\n",
345                          (int)ielen);
346 }
347
348
349 /*
350  * Terminate all reservations owned by, or targeted at, 'uwb_dev'.
351  */
352 static void uwb_drp_terminate_all(struct uwb_rc *rc, struct uwb_dev *uwb_dev)
353 {
354         struct uwb_rsv *rsv;
355
356         list_for_each_entry(rsv, &rc->reservations, rc_node) {
357                 if (rsv->owner == uwb_dev
358                     || (rsv->target.type == UWB_RSV_TARGET_DEV && rsv->target.dev == uwb_dev))
359                         uwb_rsv_remove(rsv);
360         }
361 }
362
363
364 /**
365  * uwbd_evt_handle_rc_drp - handle a DRP_IE event
366  * @evt: the DRP_IE event from the radio controller
367  *
368  * This processes DRP notifications from the radio controller, either
369  * initiating a new reservation or transitioning an existing
370  * reservation into a different state.
371  *
372  * DRP notifications can occur for three different reasons:
373  *
374  * - UWB_DRP_NOTIF_DRP_IE_RECVD: one or more DRP IEs with the RC as
375  *   the target or source have been recieved.
376  *
377  *   These DRP IEs could be new or for an existing reservation.
378  *
379  *   If the DRP IE for an existing reservation ceases to be to
380  *   recieved for at least mMaxLostBeacons, the reservation should be
381  *   considered to be terminated.  Note that the TERMINATE reason (see
382  *   below) may not always be signalled (e.g., the remote device has
383  *   two or more reservations established with the RC).
384  *
385  * - UWB_DRP_NOTIF_CONFLICT: DRP IEs from any device in the beacon
386  *   group conflict with the RC's reservations.
387  *
388  * - UWB_DRP_NOTIF_TERMINATE: DRP IEs are no longer being received
389  *   from a device (i.e., it's terminated all reservations).
390  *
391  * Only the software state of the reservations is changed; the setting
392  * of the radio controller's DRP IEs is done after all the events in
393  * an event buffer are processed.  This saves waiting multiple times
394  * for the SET_DRP_IE command to complete.
395  */
396 int uwbd_evt_handle_rc_drp(struct uwb_event *evt)
397 {
398         struct device *dev = &evt->rc->uwb_dev.dev;
399         struct uwb_rc *rc = evt->rc;
400         struct uwb_rc_evt_drp *drp_evt;
401         size_t ielength, bytes_left;
402         struct uwb_dev_addr src_addr;
403         struct uwb_dev *src_dev;
404         int reason;
405
406         /* Is there enough data to decode the event (and any IEs in
407            its payload)? */
408         if (evt->notif.size < sizeof(*drp_evt)) {
409                 dev_err(dev, "DRP event: Not enough data to decode event "
410                         "[%zu bytes left, %zu needed]\n",
411                         evt->notif.size, sizeof(*drp_evt));
412                 return 0;
413         }
414         bytes_left = evt->notif.size - sizeof(*drp_evt);
415         drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp, rceb);
416         ielength = le16_to_cpu(drp_evt->ie_length);
417         if (bytes_left != ielength) {
418                 dev_err(dev, "DRP event: Not enough data in payload [%zu"
419                         "bytes left, %zu declared in the event]\n",
420                         bytes_left, ielength);
421                 return 0;
422         }
423
424         memcpy(src_addr.data, &drp_evt->src_addr, sizeof(src_addr));
425         src_dev = uwb_dev_get_by_devaddr(rc, &src_addr);
426         if (!src_dev) {
427                 /*
428                  * A DRP notification from an unrecognized device.
429                  *
430                  * This is probably from a WUSB device that doesn't
431                  * have an EUI-48 and therefore doesn't show up in the
432                  * UWB device database.  It's safe to simply ignore
433                  * these.
434                  */
435                 return 0;
436         }
437
438         mutex_lock(&rc->rsvs_mutex);
439
440         reason = uwb_rc_evt_drp_reason(drp_evt);
441
442         switch (reason) {
443         case UWB_DRP_NOTIF_DRP_IE_RCVD:
444                 uwb_drp_process_all(rc, drp_evt, ielength, src_dev);
445                 break;
446         case UWB_DRP_NOTIF_CONFLICT:
447                 uwb_drp_process_conflict_all(rc, drp_evt, ielength, src_dev);
448                 break;
449         case UWB_DRP_NOTIF_TERMINATE:
450                 uwb_drp_terminate_all(rc, src_dev);
451                 break;
452         default:
453                 dev_warn(dev, "ignored DRP event with reason code: %d\n", reason);
454                 break;
455         }
456
457         mutex_unlock(&rc->rsvs_mutex);
458
459         uwb_dev_put(src_dev);
460         return 0;
461 }