5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 #include <linux/kernel.h>
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/device.h>
29 #include <linux/err.h>
30 #include <linux/kdev_t.h>
32 #include "uwb-internal.h"
34 /* Start Beaconing command structure */
35 struct uwb_rc_cmd_start_beacon
{
39 } __attribute__((packed
));
42 static int uwb_rc_start_beacon(struct uwb_rc
*rc
, u16 bpst_offset
, u8 channel
)
45 struct uwb_rc_cmd_start_beacon
*cmd
;
46 struct uwb_rc_evt_confirm reply
;
48 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
51 cmd
->rccb
.bCommandType
= UWB_RC_CET_GENERAL
;
52 cmd
->rccb
.wCommand
= cpu_to_le16(UWB_RC_CMD_START_BEACON
);
53 cmd
->wBPSTOffset
= cpu_to_le16(bpst_offset
);
54 cmd
->bChannelNumber
= channel
;
55 reply
.rceb
.bEventType
= UWB_RC_CET_GENERAL
;
56 reply
.rceb
.wEvent
= UWB_RC_CMD_START_BEACON
;
57 result
= uwb_rc_cmd(rc
, "START-BEACON", &cmd
->rccb
, sizeof(*cmd
),
58 &reply
.rceb
, sizeof(reply
));
61 if (reply
.bResultCode
!= UWB_RC_RES_SUCCESS
) {
62 dev_err(&rc
->uwb_dev
.dev
,
63 "START-BEACON: command execution failed: %s (%d)\n",
64 uwb_rc_strerror(reply
.bResultCode
), reply
.bResultCode
);
72 static int uwb_rc_stop_beacon(struct uwb_rc
*rc
)
76 struct uwb_rc_evt_confirm reply
;
78 cmd
= kzalloc(sizeof(*cmd
), GFP_KERNEL
);
81 cmd
->bCommandType
= UWB_RC_CET_GENERAL
;
82 cmd
->wCommand
= cpu_to_le16(UWB_RC_CMD_STOP_BEACON
);
83 reply
.rceb
.bEventType
= UWB_RC_CET_GENERAL
;
84 reply
.rceb
.wEvent
= UWB_RC_CMD_STOP_BEACON
;
85 result
= uwb_rc_cmd(rc
, "STOP-BEACON", cmd
, sizeof(*cmd
),
86 &reply
.rceb
, sizeof(reply
));
89 if (reply
.bResultCode
!= UWB_RC_RES_SUCCESS
) {
90 dev_err(&rc
->uwb_dev
.dev
,
91 "STOP-BEACON: command execution failed: %s (%d)\n",
92 uwb_rc_strerror(reply
.bResultCode
), reply
.bResultCode
);
103 * @rc: UWB Radio Controller to operate on
104 * @channel: UWB channel on which to beacon (WUSB[table
105 * 5-12]). If -1, stop beaconing.
106 * @bpst_offset: Beacon Period Start Time offset; FIXME-do zero
108 * According to WHCI 0.95 [4.13.6] the driver will only receive the RCEB
109 * of a SET IE command after the device sent the first beacon that includes
110 * the IEs specified in the SET IE command. So, after we start beaconing we
111 * check if there is anything in the IE cache and call the SET IE command
114 int uwb_rc_beacon(struct uwb_rc
*rc
, int channel
, unsigned bpst_offset
)
117 struct device
*dev
= &rc
->uwb_dev
.dev
;
122 result
= uwb_rc_stop_beacon(rc
);
124 /* channel >= 0...dah */
125 result
= uwb_rc_start_beacon(rc
, bpst_offset
, channel
);
128 if (le16_to_cpu(rc
->ies
->wIELength
) > 0) {
129 result
= uwb_rc_set_ie(rc
, rc
->ies
);
131 dev_err(dev
, "Cannot set new IE on device: "
133 result
= uwb_rc_stop_beacon(rc
);
141 rc
->beaconing
= channel
;
148 * The purpose of this is to speed up the lookup of becon information
149 * when a new beacon arrives. The UWB Daemon uses it also to keep a
150 * tab of which devices are in radio distance and which not. When a
151 * device's beacon stays present for more than a certain amount of
152 * time, it is considered a new, usable device. When a beacon ceases
153 * to be received for a certain amount of time, it is considered that
154 * the device is gone.
156 * FIXME: use an allocator for the entries
157 * FIXME: use something faster for search than a list
160 void uwb_bce_kfree(struct kref
*_bce
)
162 struct uwb_beca_e
*bce
= container_of(_bce
, struct uwb_beca_e
, refcnt
);
169 /* Find a beacon by dev addr in the cache */
171 struct uwb_beca_e
*__uwb_beca_find_bydev(struct uwb_rc
*rc
,
172 const struct uwb_dev_addr
*dev_addr
)
174 struct uwb_beca_e
*bce
, *next
;
175 list_for_each_entry_safe(bce
, next
, &rc
->uwb_beca
.list
, node
) {
176 if (!memcmp(&bce
->dev_addr
, dev_addr
, sizeof(bce
->dev_addr
)))
184 /* Find a beacon by dev addr in the cache */
186 struct uwb_beca_e
*__uwb_beca_find_bymac(struct uwb_rc
*rc
,
187 const struct uwb_mac_addr
*mac_addr
)
189 struct uwb_beca_e
*bce
, *next
;
190 list_for_each_entry_safe(bce
, next
, &rc
->uwb_beca
.list
, node
) {
191 if (!memcmp(bce
->mac_addr
, mac_addr
->data
,
192 sizeof(struct uwb_mac_addr
)))
201 * uwb_dev_get_by_devaddr - get a UWB device with a specific DevAddr
202 * @rc: the radio controller that saw the device
203 * @devaddr: DevAddr of the UWB device to find
205 * There may be more than one matching device (in the case of a
206 * DevAddr conflict), but only the first one is returned.
208 struct uwb_dev
*uwb_dev_get_by_devaddr(struct uwb_rc
*rc
,
209 const struct uwb_dev_addr
*devaddr
)
211 struct uwb_dev
*found
= NULL
;
212 struct uwb_beca_e
*bce
;
214 mutex_lock(&rc
->uwb_beca
.mutex
);
215 bce
= __uwb_beca_find_bydev(rc
, devaddr
);
217 found
= uwb_dev_try_get(rc
, bce
->uwb_dev
);
218 mutex_unlock(&rc
->uwb_beca
.mutex
);
224 * uwb_dev_get_by_macaddr - get a UWB device with a specific EUI-48
225 * @rc: the radio controller that saw the device
226 * @devaddr: EUI-48 of the UWB device to find
228 struct uwb_dev
*uwb_dev_get_by_macaddr(struct uwb_rc
*rc
,
229 const struct uwb_mac_addr
*macaddr
)
231 struct uwb_dev
*found
= NULL
;
232 struct uwb_beca_e
*bce
;
234 mutex_lock(&rc
->uwb_beca
.mutex
);
235 bce
= __uwb_beca_find_bymac(rc
, macaddr
);
237 found
= uwb_dev_try_get(rc
, bce
->uwb_dev
);
238 mutex_unlock(&rc
->uwb_beca
.mutex
);
243 /* Initialize a beacon cache entry */
244 static void uwb_beca_e_init(struct uwb_beca_e
*bce
)
246 mutex_init(&bce
->mutex
);
247 kref_init(&bce
->refcnt
);
248 stats_init(&bce
->lqe_stats
);
249 stats_init(&bce
->rssi_stats
);
253 * Add a beacon to the cache
255 * @be: Beacon event information
256 * @bf: Beacon frame (part of b, really)
257 * @ts_jiffies: Timestamp (in jiffies) when the beacon was received
260 struct uwb_beca_e
*__uwb_beca_add(struct uwb_rc
*rc
,
261 struct uwb_rc_evt_beacon
*be
,
262 struct uwb_beacon_frame
*bf
,
263 unsigned long ts_jiffies
)
265 struct uwb_beca_e
*bce
;
267 bce
= kzalloc(sizeof(*bce
), GFP_KERNEL
);
270 uwb_beca_e_init(bce
);
271 bce
->ts_jiffies
= ts_jiffies
;
273 list_add(&bce
->node
, &rc
->uwb_beca
.list
);
278 * Wipe out beacon entries that became stale
280 * Remove associated devicest too.
282 void uwb_beca_purge(struct uwb_rc
*rc
)
284 struct uwb_beca_e
*bce
, *next
;
285 unsigned long expires
;
287 mutex_lock(&rc
->uwb_beca
.mutex
);
288 list_for_each_entry_safe(bce
, next
, &rc
->uwb_beca
.list
, node
) {
289 expires
= bce
->ts_jiffies
+ msecs_to_jiffies(beacon_timeout_ms
);
290 if (time_after(jiffies
, expires
)) {
291 uwbd_dev_offair(bce
);
292 list_del(&bce
->node
);
296 mutex_unlock(&rc
->uwb_beca
.mutex
);
299 /* Clean up the whole beacon cache. Called on shutdown */
300 void uwb_beca_release(struct uwb_rc
*rc
)
302 struct uwb_beca_e
*bce
, *next
;
304 mutex_lock(&rc
->uwb_beca
.mutex
);
305 list_for_each_entry_safe(bce
, next
, &rc
->uwb_beca
.list
, node
) {
306 list_del(&bce
->node
);
309 mutex_unlock(&rc
->uwb_beca
.mutex
);
312 static void uwb_beacon_print(struct uwb_rc
*rc
, struct uwb_rc_evt_beacon
*be
,
313 struct uwb_beacon_frame
*bf
)
315 char macbuf
[UWB_ADDR_STRSIZE
];
316 char devbuf
[UWB_ADDR_STRSIZE
];
317 char dstbuf
[UWB_ADDR_STRSIZE
];
319 uwb_mac_addr_print(macbuf
, sizeof(macbuf
), &bf
->Device_Identifier
);
320 uwb_dev_addr_print(devbuf
, sizeof(devbuf
), &bf
->hdr
.SrcAddr
);
321 uwb_dev_addr_print(dstbuf
, sizeof(dstbuf
), &bf
->hdr
.DestAddr
);
322 dev_info(&rc
->uwb_dev
.dev
,
323 "BEACON from %s to %s (ch%u offset %u slot %u MAC %s)\n",
324 devbuf
, dstbuf
, be
->bChannelNumber
, be
->wBPSTOffset
,
325 bf
->Beacon_Slot_Number
, macbuf
);
329 * @bce: beacon cache entry, referenced
331 ssize_t
uwb_bce_print_IEs(struct uwb_dev
*uwb_dev
, struct uwb_beca_e
*bce
,
332 char *buf
, size_t size
)
335 struct uwb_rc_evt_beacon
*be
;
336 struct uwb_beacon_frame
*bf
;
338 struct uwb_ie_hdr
*ies
;
340 mutex_lock(&bce
->mutex
);
344 bf
= (struct uwb_beacon_frame
*)bce
->be
->BeaconInfo
;
345 ies_len
= be
->wBeaconInfoLength
- sizeof(struct uwb_beacon_frame
);
346 ies
= (struct uwb_ie_hdr
*)bf
->IEData
;
348 result
= uwb_ie_dump_hex(ies
, ies_len
, buf
, size
);
351 mutex_unlock(&bce
->mutex
);
357 * Verify that the beacon event, frame and IEs are ok
359 static int uwb_verify_beacon(struct uwb_rc
*rc
, struct uwb_event
*evt
,
360 struct uwb_rc_evt_beacon
*be
)
362 int result
= -EINVAL
;
363 struct uwb_beacon_frame
*bf
;
364 struct device
*dev
= &rc
->uwb_dev
.dev
;
366 /* Is there enough data to decode a beacon frame? */
367 if (evt
->notif
.size
< sizeof(*be
) + sizeof(*bf
)) {
368 dev_err(dev
, "BEACON event: Not enough data to decode "
369 "(%zu vs %zu bytes needed)\n", evt
->notif
.size
,
370 sizeof(*be
) + sizeof(*bf
));
373 /* FIXME: make sure beacon frame IEs are fine and that the whole thing
381 * Handle UWB_RC_EVT_BEACON events
383 * We check the beacon cache to see how the received beacon fares. If
384 * is there already we refresh the timestamp. If not we create a new
387 * According to the WHCI and WUSB specs, only one beacon frame is
388 * allowed per notification block, so we don't bother about scanning
391 int uwbd_evt_handle_rc_beacon(struct uwb_event
*evt
)
393 int result
= -EINVAL
;
395 struct uwb_rc_evt_beacon
*be
;
396 struct uwb_beacon_frame
*bf
;
397 struct uwb_beca_e
*bce
;
398 unsigned long last_ts
;
401 be
= container_of(evt
->notif
.rceb
, struct uwb_rc_evt_beacon
, rceb
);
402 result
= uwb_verify_beacon(rc
, evt
, be
);
406 /* FIXME: handle alien beacons. */
407 if (be
->bBeaconType
== UWB_RC_BEACON_TYPE_OL_ALIEN
||
408 be
->bBeaconType
== UWB_RC_BEACON_TYPE_NOL_ALIEN
) {
412 bf
= (struct uwb_beacon_frame
*) be
->BeaconInfo
;
415 * Drop beacons from devices with a NULL EUI-48 -- they cannot
416 * be uniquely identified.
418 * It's expected that these will all be WUSB devices and they
419 * have a WUSB specific connection method so ignoring them
420 * here shouldn't be a problem.
422 if (uwb_mac_addr_bcast(&bf
->Device_Identifier
))
425 mutex_lock(&rc
->uwb_beca
.mutex
);
426 bce
= __uwb_beca_find_bymac(rc
, &bf
->Device_Identifier
);
428 /* Not in there, a new device is pinging */
429 uwb_beacon_print(evt
->rc
, be
, bf
);
430 bce
= __uwb_beca_add(rc
, be
, bf
, evt
->ts_jiffies
);
432 mutex_unlock(&rc
->uwb_beca
.mutex
);
436 mutex_unlock(&rc
->uwb_beca
.mutex
);
438 mutex_lock(&bce
->mutex
);
439 /* purge old beacon data */
442 last_ts
= bce
->ts_jiffies
;
444 /* Update commonly used fields */
445 bce
->ts_jiffies
= evt
->ts_jiffies
;
447 bce
->dev_addr
= bf
->hdr
.SrcAddr
;
448 bce
->mac_addr
= &bf
->Device_Identifier
;
449 be
->wBPSTOffset
= le16_to_cpu(be
->wBPSTOffset
);
450 be
->wBeaconInfoLength
= le16_to_cpu(be
->wBeaconInfoLength
);
451 stats_add_sample(&bce
->lqe_stats
, be
->bLQI
- 7);
452 stats_add_sample(&bce
->rssi_stats
, be
->bRSSI
+ 18);
455 * This might be a beacon from a new device.
457 if (bce
->uwb_dev
== NULL
)
458 uwbd_dev_onair(evt
->rc
, bce
);
460 mutex_unlock(&bce
->mutex
);
462 return 1; /* we keep the event data */
466 * Handle UWB_RC_EVT_BEACON_SIZE events
470 int uwbd_evt_handle_rc_beacon_size(struct uwb_event
*evt
)
472 int result
= -EINVAL
;
473 struct device
*dev
= &evt
->rc
->uwb_dev
.dev
;
474 struct uwb_rc_evt_beacon_size
*bs
;
476 /* Is there enough data to decode the event? */
477 if (evt
->notif
.size
< sizeof(*bs
)) {
478 dev_err(dev
, "BEACON SIZE notification: Not enough data to "
479 "decode (%zu vs %zu bytes needed)\n",
480 evt
->notif
.size
, sizeof(*bs
));
483 bs
= container_of(evt
->notif
.rceb
, struct uwb_rc_evt_beacon_size
, rceb
);
485 dev_info(dev
, "Beacon size changed to %u bytes "
486 "(FIXME: action?)\n", le16_to_cpu(bs
->wNewBeaconSize
));
488 /* temporary hack until we do something with this message... */
489 static unsigned count
;
490 if (++count
% 1000 == 0)
491 dev_info(dev
, "Beacon size changed %u times "
492 "(FIXME: action?)\n", count
);
500 * uwbd_evt_handle_rc_bp_slot_change - handle a BP_SLOT_CHANGE event
501 * @evt: the BP_SLOT_CHANGE notification from the radio controller
503 * If the event indicates that no beacon period slots were available
504 * then radio controller has transitioned to a non-beaconing state.
505 * Otherwise, simply save the current beacon slot.
507 int uwbd_evt_handle_rc_bp_slot_change(struct uwb_event
*evt
)
509 struct uwb_rc
*rc
= evt
->rc
;
510 struct device
*dev
= &rc
->uwb_dev
.dev
;
511 struct uwb_rc_evt_bp_slot_change
*bpsc
;
513 if (evt
->notif
.size
< sizeof(*bpsc
)) {
514 dev_err(dev
, "BP SLOT CHANGE event: Not enough data\n");
517 bpsc
= container_of(evt
->notif
.rceb
, struct uwb_rc_evt_bp_slot_change
, rceb
);
519 mutex_lock(&rc
->uwb_dev
.mutex
);
520 if (uwb_rc_evt_bp_slot_change_no_slot(bpsc
)) {
521 dev_info(dev
, "stopped beaconing: No free slots in BP\n");
524 rc
->uwb_dev
.beacon_slot
= uwb_rc_evt_bp_slot_change_slot_num(bpsc
);
525 mutex_unlock(&rc
->uwb_dev
.mutex
);
531 * Handle UWB_RC_EVT_BPOIE_CHANGE events
536 struct uwb_ie_hdr hdr
;
539 } __attribute__((packed
));
541 int uwbd_evt_handle_rc_bpoie_change(struct uwb_event
*evt
)
543 int result
= -EINVAL
;
544 struct device
*dev
= &evt
->rc
->uwb_dev
.dev
;
545 struct uwb_rc_evt_bpoie_change
*bpoiec
;
546 struct uwb_ie_bpo
*bpoie
;
547 static unsigned count
; /* FIXME: this is a temp hack */
550 /* Is there enough data to decode it? */
551 if (evt
->notif
.size
< sizeof(*bpoiec
)) {
552 dev_err(dev
, "BPOIEC notification: Not enough data to "
553 "decode (%zu vs %zu bytes needed)\n",
554 evt
->notif
.size
, sizeof(*bpoiec
));
557 bpoiec
= container_of(evt
->notif
.rceb
, struct uwb_rc_evt_bpoie_change
, rceb
);
558 iesize
= le16_to_cpu(bpoiec
->wBPOIELength
);
559 if (iesize
< sizeof(*bpoie
)) {
560 dev_err(dev
, "BPOIEC notification: Not enough IE data to "
561 "decode (%zu vs %zu bytes needed)\n",
562 iesize
, sizeof(*bpoie
));
565 if (++count
% 1000 == 0) /* Lame placeholder */
566 dev_info(dev
, "BPOIE: %u changes received\n", count
);
568 * FIXME: At this point we should go over all the IEs in the
569 * bpoiec->BPOIE array and act on each.
577 * Print beaconing state.
579 static ssize_t
uwb_rc_beacon_show(struct device
*dev
,
580 struct device_attribute
*attr
, char *buf
)
582 struct uwb_dev
*uwb_dev
= to_uwb_dev(dev
);
583 struct uwb_rc
*rc
= uwb_dev
->rc
;
586 mutex_lock(&rc
->uwb_dev
.mutex
);
587 result
= sprintf(buf
, "%d\n", rc
->beaconing
);
588 mutex_unlock(&rc
->uwb_dev
.mutex
);
593 * Start beaconing on the specified channel, or stop beaconing.
595 static ssize_t
uwb_rc_beacon_store(struct device
*dev
,
596 struct device_attribute
*attr
,
597 const char *buf
, size_t size
)
599 struct uwb_dev
*uwb_dev
= to_uwb_dev(dev
);
600 struct uwb_rc
*rc
= uwb_dev
->rc
;
602 ssize_t result
= -EINVAL
;
604 result
= sscanf(buf
, "%d", &channel
);
606 result
= uwb_radio_force_channel(rc
, channel
);
608 return result
< 0 ? result
: size
;
610 DEVICE_ATTR(beacon
, S_IRUGO
| S_IWUSR
, uwb_rc_beacon_show
, uwb_rc_beacon_store
);