mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Tejun Heo](/assets/img/avatar_default.png)
percpu.h is included by sched.h and module.h and thus ends up being included when building most .c files. percpu.h includes slab.h which in turn includes gfp.h making everything defined by the two files universally available and complicating inclusion dependencies. percpu.h -> slab.h dependency is about to be removed. Prepare for this change by updating users of gfp and slab facilities include those headers directly instead of assuming availability. As this conversion needs to touch large number of source files, the following script is used as the basis of conversion. http://userweb.kernel.org/~tj/misc/slabh-sweep.py The script does the followings. * Scan files for gfp and slab usages and update includes such that only the necessary includes are there. ie. if only gfp is used, gfp.h, if slab is used, slab.h. * When the script inserts a new include, it looks at the include blocks and try to put the new include such that its order conforms to its surrounding. It's put in the include block which contains core kernel includes, in the same order that the rest are ordered - alphabetical, Christmas tree, rev-Xmas-tree or at the end if there doesn't seem to be any matching order. * If the script can't find a place to put a new include (mostly because the file doesn't have fitting include block), it prints out an error message indicating which .h file needs to be added to the file. The conversion was done in the following steps. 1. The initial automatic conversion of all .c files updated slightly over 4000 files, deleting around 700 includes and adding ~480 gfp.h and ~3000 slab.h inclusions. The script emitted errors for ~400 files. 2. Each error was manually checked. Some didn't need the inclusion, some needed manual addition while adding it to implementation .h or embedding .c file was more appropriate for others. This step added inclusions to around 150 files. 3. The script was run again and the output was compared to the edits from #2 to make sure no file was left behind. 4. Several build tests were done and a couple of problems were fixed. e.g. lib/decompress_*.c used malloc/free() wrappers around slab APIs requiring slab.h to be added manually. 5. The script was run on all .h files but without automatically editing them as sprinkling gfp.h and slab.h inclusions around .h files could easily lead to inclusion dependency hell. Most gfp.h inclusion directives were ignored as stuff from gfp.h was usually wildly available and often used in preprocessor macros. Each slab.h inclusion directive was examined and added manually as necessary. 6. percpu.h was updated not to include slab.h. 7. Build test were done on the following configurations and failures were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my distributed build env didn't work with gcov compiles) and a few more options had to be turned off depending on archs to make things build (like ipr on powerpc/64 which failed due to missing writeq). * x86 and x86_64 UP and SMP allmodconfig and a custom test config. * powerpc and powerpc64 SMP allmodconfig * sparc and sparc64 SMP allmodconfig * ia64 SMP allmodconfig * s390 SMP allmodconfig * alpha SMP allmodconfig * um on x86_64 SMP allmodconfig 8. percpu.h modifications were reverted so that it could be applied as a separate patch and serve as bisection point. Given the fact that I had only a couple of failures from tests on step 6, I'm fairly confident about the coverage of this conversion patch. If there is a breakage, it's likely to be something in one of the arch headers which should be easily discoverable easily on most builds of the specific arch. Signed-off-by: Tejun Heo <tj@kernel.org> Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
609 lines
16 KiB
C
609 lines
16 KiB
C
/*
|
|
* Ultra Wide Band
|
|
* Beacon management
|
|
*
|
|
* Copyright (C) 2005-2006 Intel Corporation
|
|
* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License version
|
|
* 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*
|
|
*
|
|
* FIXME: docs
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/module.h>
|
|
#include <linux/device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/kdev_t.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "uwb-internal.h"
|
|
|
|
/* Start Beaconing command structure */
|
|
struct uwb_rc_cmd_start_beacon {
|
|
struct uwb_rccb rccb;
|
|
__le16 wBPSTOffset;
|
|
u8 bChannelNumber;
|
|
} __attribute__((packed));
|
|
|
|
|
|
static int uwb_rc_start_beacon(struct uwb_rc *rc, u16 bpst_offset, u8 channel)
|
|
{
|
|
int result;
|
|
struct uwb_rc_cmd_start_beacon *cmd;
|
|
struct uwb_rc_evt_confirm reply;
|
|
|
|
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
|
|
if (cmd == NULL)
|
|
return -ENOMEM;
|
|
cmd->rccb.bCommandType = UWB_RC_CET_GENERAL;
|
|
cmd->rccb.wCommand = cpu_to_le16(UWB_RC_CMD_START_BEACON);
|
|
cmd->wBPSTOffset = cpu_to_le16(bpst_offset);
|
|
cmd->bChannelNumber = channel;
|
|
reply.rceb.bEventType = UWB_RC_CET_GENERAL;
|
|
reply.rceb.wEvent = UWB_RC_CMD_START_BEACON;
|
|
result = uwb_rc_cmd(rc, "START-BEACON", &cmd->rccb, sizeof(*cmd),
|
|
&reply.rceb, sizeof(reply));
|
|
if (result < 0)
|
|
goto error_cmd;
|
|
if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
|
|
dev_err(&rc->uwb_dev.dev,
|
|
"START-BEACON: command execution failed: %s (%d)\n",
|
|
uwb_rc_strerror(reply.bResultCode), reply.bResultCode);
|
|
result = -EIO;
|
|
}
|
|
error_cmd:
|
|
kfree(cmd);
|
|
return result;
|
|
}
|
|
|
|
static int uwb_rc_stop_beacon(struct uwb_rc *rc)
|
|
{
|
|
int result;
|
|
struct uwb_rccb *cmd;
|
|
struct uwb_rc_evt_confirm reply;
|
|
|
|
cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
|
|
if (cmd == NULL)
|
|
return -ENOMEM;
|
|
cmd->bCommandType = UWB_RC_CET_GENERAL;
|
|
cmd->wCommand = cpu_to_le16(UWB_RC_CMD_STOP_BEACON);
|
|
reply.rceb.bEventType = UWB_RC_CET_GENERAL;
|
|
reply.rceb.wEvent = UWB_RC_CMD_STOP_BEACON;
|
|
result = uwb_rc_cmd(rc, "STOP-BEACON", cmd, sizeof(*cmd),
|
|
&reply.rceb, sizeof(reply));
|
|
if (result < 0)
|
|
goto error_cmd;
|
|
if (reply.bResultCode != UWB_RC_RES_SUCCESS) {
|
|
dev_err(&rc->uwb_dev.dev,
|
|
"STOP-BEACON: command execution failed: %s (%d)\n",
|
|
uwb_rc_strerror(reply.bResultCode), reply.bResultCode);
|
|
result = -EIO;
|
|
}
|
|
error_cmd:
|
|
kfree(cmd);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Start/stop beacons
|
|
*
|
|
* @rc: UWB Radio Controller to operate on
|
|
* @channel: UWB channel on which to beacon (WUSB[table
|
|
* 5-12]). If -1, stop beaconing.
|
|
* @bpst_offset: Beacon Period Start Time offset; FIXME-do zero
|
|
*
|
|
* According to WHCI 0.95 [4.13.6] the driver will only receive the RCEB
|
|
* of a SET IE command after the device sent the first beacon that includes
|
|
* the IEs specified in the SET IE command. So, after we start beaconing we
|
|
* check if there is anything in the IE cache and call the SET IE command
|
|
* if needed.
|
|
*/
|
|
int uwb_rc_beacon(struct uwb_rc *rc, int channel, unsigned bpst_offset)
|
|
{
|
|
int result;
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
|
|
if (channel < 0)
|
|
channel = -1;
|
|
if (channel == -1)
|
|
result = uwb_rc_stop_beacon(rc);
|
|
else {
|
|
/* channel >= 0...dah */
|
|
result = uwb_rc_start_beacon(rc, bpst_offset, channel);
|
|
if (result < 0)
|
|
return result;
|
|
if (le16_to_cpu(rc->ies->wIELength) > 0) {
|
|
result = uwb_rc_set_ie(rc, rc->ies);
|
|
if (result < 0) {
|
|
dev_err(dev, "Cannot set new IE on device: "
|
|
"%d\n", result);
|
|
result = uwb_rc_stop_beacon(rc);
|
|
channel = -1;
|
|
bpst_offset = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result >= 0)
|
|
rc->beaconing = channel;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Beacon cache
|
|
*
|
|
* The purpose of this is to speed up the lookup of becon information
|
|
* when a new beacon arrives. The UWB Daemon uses it also to keep a
|
|
* tab of which devices are in radio distance and which not. When a
|
|
* device's beacon stays present for more than a certain amount of
|
|
* time, it is considered a new, usable device. When a beacon ceases
|
|
* to be received for a certain amount of time, it is considered that
|
|
* the device is gone.
|
|
*
|
|
* FIXME: use an allocator for the entries
|
|
* FIXME: use something faster for search than a list
|
|
*/
|
|
|
|
void uwb_bce_kfree(struct kref *_bce)
|
|
{
|
|
struct uwb_beca_e *bce = container_of(_bce, struct uwb_beca_e, refcnt);
|
|
|
|
kfree(bce->be);
|
|
kfree(bce);
|
|
}
|
|
|
|
|
|
/* Find a beacon by dev addr in the cache */
|
|
static
|
|
struct uwb_beca_e *__uwb_beca_find_bydev(struct uwb_rc *rc,
|
|
const struct uwb_dev_addr *dev_addr)
|
|
{
|
|
struct uwb_beca_e *bce, *next;
|
|
list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
|
|
if (!memcmp(&bce->dev_addr, dev_addr, sizeof(bce->dev_addr)))
|
|
goto out;
|
|
}
|
|
bce = NULL;
|
|
out:
|
|
return bce;
|
|
}
|
|
|
|
/* Find a beacon by dev addr in the cache */
|
|
static
|
|
struct uwb_beca_e *__uwb_beca_find_bymac(struct uwb_rc *rc,
|
|
const struct uwb_mac_addr *mac_addr)
|
|
{
|
|
struct uwb_beca_e *bce, *next;
|
|
list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
|
|
if (!memcmp(bce->mac_addr, mac_addr->data,
|
|
sizeof(struct uwb_mac_addr)))
|
|
goto out;
|
|
}
|
|
bce = NULL;
|
|
out:
|
|
return bce;
|
|
}
|
|
|
|
/**
|
|
* uwb_dev_get_by_devaddr - get a UWB device with a specific DevAddr
|
|
* @rc: the radio controller that saw the device
|
|
* @devaddr: DevAddr of the UWB device to find
|
|
*
|
|
* There may be more than one matching device (in the case of a
|
|
* DevAddr conflict), but only the first one is returned.
|
|
*/
|
|
struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc,
|
|
const struct uwb_dev_addr *devaddr)
|
|
{
|
|
struct uwb_dev *found = NULL;
|
|
struct uwb_beca_e *bce;
|
|
|
|
mutex_lock(&rc->uwb_beca.mutex);
|
|
bce = __uwb_beca_find_bydev(rc, devaddr);
|
|
if (bce)
|
|
found = uwb_dev_try_get(rc, bce->uwb_dev);
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
|
|
return found;
|
|
}
|
|
|
|
/**
|
|
* uwb_dev_get_by_macaddr - get a UWB device with a specific EUI-48
|
|
* @rc: the radio controller that saw the device
|
|
* @devaddr: EUI-48 of the UWB device to find
|
|
*/
|
|
struct uwb_dev *uwb_dev_get_by_macaddr(struct uwb_rc *rc,
|
|
const struct uwb_mac_addr *macaddr)
|
|
{
|
|
struct uwb_dev *found = NULL;
|
|
struct uwb_beca_e *bce;
|
|
|
|
mutex_lock(&rc->uwb_beca.mutex);
|
|
bce = __uwb_beca_find_bymac(rc, macaddr);
|
|
if (bce)
|
|
found = uwb_dev_try_get(rc, bce->uwb_dev);
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
|
|
return found;
|
|
}
|
|
|
|
/* Initialize a beacon cache entry */
|
|
static void uwb_beca_e_init(struct uwb_beca_e *bce)
|
|
{
|
|
mutex_init(&bce->mutex);
|
|
kref_init(&bce->refcnt);
|
|
stats_init(&bce->lqe_stats);
|
|
stats_init(&bce->rssi_stats);
|
|
}
|
|
|
|
/*
|
|
* Add a beacon to the cache
|
|
*
|
|
* @be: Beacon event information
|
|
* @bf: Beacon frame (part of b, really)
|
|
* @ts_jiffies: Timestamp (in jiffies) when the beacon was received
|
|
*/
|
|
static
|
|
struct uwb_beca_e *__uwb_beca_add(struct uwb_rc *rc,
|
|
struct uwb_rc_evt_beacon *be,
|
|
struct uwb_beacon_frame *bf,
|
|
unsigned long ts_jiffies)
|
|
{
|
|
struct uwb_beca_e *bce;
|
|
|
|
bce = kzalloc(sizeof(*bce), GFP_KERNEL);
|
|
if (bce == NULL)
|
|
return NULL;
|
|
uwb_beca_e_init(bce);
|
|
bce->ts_jiffies = ts_jiffies;
|
|
bce->uwb_dev = NULL;
|
|
list_add(&bce->node, &rc->uwb_beca.list);
|
|
return bce;
|
|
}
|
|
|
|
/*
|
|
* Wipe out beacon entries that became stale
|
|
*
|
|
* Remove associated devicest too.
|
|
*/
|
|
void uwb_beca_purge(struct uwb_rc *rc)
|
|
{
|
|
struct uwb_beca_e *bce, *next;
|
|
unsigned long expires;
|
|
|
|
mutex_lock(&rc->uwb_beca.mutex);
|
|
list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
|
|
expires = bce->ts_jiffies + msecs_to_jiffies(beacon_timeout_ms);
|
|
if (time_after(jiffies, expires)) {
|
|
uwbd_dev_offair(bce);
|
|
}
|
|
}
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
}
|
|
|
|
/* Clean up the whole beacon cache. Called on shutdown */
|
|
void uwb_beca_release(struct uwb_rc *rc)
|
|
{
|
|
struct uwb_beca_e *bce, *next;
|
|
|
|
mutex_lock(&rc->uwb_beca.mutex);
|
|
list_for_each_entry_safe(bce, next, &rc->uwb_beca.list, node) {
|
|
list_del(&bce->node);
|
|
uwb_bce_put(bce);
|
|
}
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
}
|
|
|
|
static void uwb_beacon_print(struct uwb_rc *rc, struct uwb_rc_evt_beacon *be,
|
|
struct uwb_beacon_frame *bf)
|
|
{
|
|
char macbuf[UWB_ADDR_STRSIZE];
|
|
char devbuf[UWB_ADDR_STRSIZE];
|
|
char dstbuf[UWB_ADDR_STRSIZE];
|
|
|
|
uwb_mac_addr_print(macbuf, sizeof(macbuf), &bf->Device_Identifier);
|
|
uwb_dev_addr_print(devbuf, sizeof(devbuf), &bf->hdr.SrcAddr);
|
|
uwb_dev_addr_print(dstbuf, sizeof(dstbuf), &bf->hdr.DestAddr);
|
|
dev_info(&rc->uwb_dev.dev,
|
|
"BEACON from %s to %s (ch%u offset %u slot %u MAC %s)\n",
|
|
devbuf, dstbuf, be->bChannelNumber, be->wBPSTOffset,
|
|
bf->Beacon_Slot_Number, macbuf);
|
|
}
|
|
|
|
/*
|
|
* @bce: beacon cache entry, referenced
|
|
*/
|
|
ssize_t uwb_bce_print_IEs(struct uwb_dev *uwb_dev, struct uwb_beca_e *bce,
|
|
char *buf, size_t size)
|
|
{
|
|
ssize_t result = 0;
|
|
struct uwb_rc_evt_beacon *be;
|
|
struct uwb_beacon_frame *bf;
|
|
int ies_len;
|
|
struct uwb_ie_hdr *ies;
|
|
|
|
mutex_lock(&bce->mutex);
|
|
|
|
be = bce->be;
|
|
if (be) {
|
|
bf = (struct uwb_beacon_frame *)bce->be->BeaconInfo;
|
|
ies_len = be->wBeaconInfoLength - sizeof(struct uwb_beacon_frame);
|
|
ies = (struct uwb_ie_hdr *)bf->IEData;
|
|
|
|
result = uwb_ie_dump_hex(ies, ies_len, buf, size);
|
|
}
|
|
|
|
mutex_unlock(&bce->mutex);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Verify that the beacon event, frame and IEs are ok
|
|
*/
|
|
static int uwb_verify_beacon(struct uwb_rc *rc, struct uwb_event *evt,
|
|
struct uwb_rc_evt_beacon *be)
|
|
{
|
|
int result = -EINVAL;
|
|
struct uwb_beacon_frame *bf;
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
|
|
/* Is there enough data to decode a beacon frame? */
|
|
if (evt->notif.size < sizeof(*be) + sizeof(*bf)) {
|
|
dev_err(dev, "BEACON event: Not enough data to decode "
|
|
"(%zu vs %zu bytes needed)\n", evt->notif.size,
|
|
sizeof(*be) + sizeof(*bf));
|
|
goto error;
|
|
}
|
|
/* FIXME: make sure beacon frame IEs are fine and that the whole thing
|
|
* is consistent */
|
|
result = 0;
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Handle UWB_RC_EVT_BEACON events
|
|
*
|
|
* We check the beacon cache to see how the received beacon fares. If
|
|
* is there already we refresh the timestamp. If not we create a new
|
|
* entry.
|
|
*
|
|
* According to the WHCI and WUSB specs, only one beacon frame is
|
|
* allowed per notification block, so we don't bother about scanning
|
|
* for more.
|
|
*/
|
|
int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
|
|
{
|
|
int result = -EINVAL;
|
|
struct uwb_rc *rc;
|
|
struct uwb_rc_evt_beacon *be;
|
|
struct uwb_beacon_frame *bf;
|
|
struct uwb_beca_e *bce;
|
|
unsigned long last_ts;
|
|
|
|
rc = evt->rc;
|
|
be = container_of(evt->notif.rceb, struct uwb_rc_evt_beacon, rceb);
|
|
result = uwb_verify_beacon(rc, evt, be);
|
|
if (result < 0)
|
|
return result;
|
|
|
|
/* FIXME: handle alien beacons. */
|
|
if (be->bBeaconType == UWB_RC_BEACON_TYPE_OL_ALIEN ||
|
|
be->bBeaconType == UWB_RC_BEACON_TYPE_NOL_ALIEN) {
|
|
return -ENOSYS;
|
|
}
|
|
|
|
bf = (struct uwb_beacon_frame *) be->BeaconInfo;
|
|
|
|
/*
|
|
* Drop beacons from devices with a NULL EUI-48 -- they cannot
|
|
* be uniquely identified.
|
|
*
|
|
* It's expected that these will all be WUSB devices and they
|
|
* have a WUSB specific connection method so ignoring them
|
|
* here shouldn't be a problem.
|
|
*/
|
|
if (uwb_mac_addr_bcast(&bf->Device_Identifier))
|
|
return 0;
|
|
|
|
mutex_lock(&rc->uwb_beca.mutex);
|
|
bce = __uwb_beca_find_bymac(rc, &bf->Device_Identifier);
|
|
if (bce == NULL) {
|
|
/* Not in there, a new device is pinging */
|
|
uwb_beacon_print(evt->rc, be, bf);
|
|
bce = __uwb_beca_add(rc, be, bf, evt->ts_jiffies);
|
|
if (bce == NULL) {
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
mutex_unlock(&rc->uwb_beca.mutex);
|
|
|
|
mutex_lock(&bce->mutex);
|
|
/* purge old beacon data */
|
|
kfree(bce->be);
|
|
|
|
last_ts = bce->ts_jiffies;
|
|
|
|
/* Update commonly used fields */
|
|
bce->ts_jiffies = evt->ts_jiffies;
|
|
bce->be = be;
|
|
bce->dev_addr = bf->hdr.SrcAddr;
|
|
bce->mac_addr = &bf->Device_Identifier;
|
|
be->wBPSTOffset = le16_to_cpu(be->wBPSTOffset);
|
|
be->wBeaconInfoLength = le16_to_cpu(be->wBeaconInfoLength);
|
|
stats_add_sample(&bce->lqe_stats, be->bLQI - 7);
|
|
stats_add_sample(&bce->rssi_stats, be->bRSSI + 18);
|
|
|
|
/*
|
|
* This might be a beacon from a new device.
|
|
*/
|
|
if (bce->uwb_dev == NULL)
|
|
uwbd_dev_onair(evt->rc, bce);
|
|
|
|
mutex_unlock(&bce->mutex);
|
|
|
|
return 1; /* we keep the event data */
|
|
}
|
|
|
|
/*
|
|
* Handle UWB_RC_EVT_BEACON_SIZE events
|
|
*
|
|
* XXXXX
|
|
*/
|
|
int uwbd_evt_handle_rc_beacon_size(struct uwb_event *evt)
|
|
{
|
|
int result = -EINVAL;
|
|
struct device *dev = &evt->rc->uwb_dev.dev;
|
|
struct uwb_rc_evt_beacon_size *bs;
|
|
|
|
/* Is there enough data to decode the event? */
|
|
if (evt->notif.size < sizeof(*bs)) {
|
|
dev_err(dev, "BEACON SIZE notification: Not enough data to "
|
|
"decode (%zu vs %zu bytes needed)\n",
|
|
evt->notif.size, sizeof(*bs));
|
|
goto error;
|
|
}
|
|
bs = container_of(evt->notif.rceb, struct uwb_rc_evt_beacon_size, rceb);
|
|
if (0)
|
|
dev_info(dev, "Beacon size changed to %u bytes "
|
|
"(FIXME: action?)\n", le16_to_cpu(bs->wNewBeaconSize));
|
|
else {
|
|
/* temporary hack until we do something with this message... */
|
|
static unsigned count;
|
|
if (++count % 1000 == 0)
|
|
dev_info(dev, "Beacon size changed %u times "
|
|
"(FIXME: action?)\n", count);
|
|
}
|
|
result = 0;
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* uwbd_evt_handle_rc_bp_slot_change - handle a BP_SLOT_CHANGE event
|
|
* @evt: the BP_SLOT_CHANGE notification from the radio controller
|
|
*
|
|
* If the event indicates that no beacon period slots were available
|
|
* then radio controller has transitioned to a non-beaconing state.
|
|
* Otherwise, simply save the current beacon slot.
|
|
*/
|
|
int uwbd_evt_handle_rc_bp_slot_change(struct uwb_event *evt)
|
|
{
|
|
struct uwb_rc *rc = evt->rc;
|
|
struct device *dev = &rc->uwb_dev.dev;
|
|
struct uwb_rc_evt_bp_slot_change *bpsc;
|
|
|
|
if (evt->notif.size < sizeof(*bpsc)) {
|
|
dev_err(dev, "BP SLOT CHANGE event: Not enough data\n");
|
|
return -EINVAL;
|
|
}
|
|
bpsc = container_of(evt->notif.rceb, struct uwb_rc_evt_bp_slot_change, rceb);
|
|
|
|
mutex_lock(&rc->uwb_dev.mutex);
|
|
if (uwb_rc_evt_bp_slot_change_no_slot(bpsc)) {
|
|
dev_info(dev, "stopped beaconing: No free slots in BP\n");
|
|
rc->beaconing = -1;
|
|
} else
|
|
rc->uwb_dev.beacon_slot = uwb_rc_evt_bp_slot_change_slot_num(bpsc);
|
|
mutex_unlock(&rc->uwb_dev.mutex);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Handle UWB_RC_EVT_BPOIE_CHANGE events
|
|
*
|
|
* XXXXX
|
|
*/
|
|
struct uwb_ie_bpo {
|
|
struct uwb_ie_hdr hdr;
|
|
u8 bp_length;
|
|
u8 data[];
|
|
} __attribute__((packed));
|
|
|
|
int uwbd_evt_handle_rc_bpoie_change(struct uwb_event *evt)
|
|
{
|
|
int result = -EINVAL;
|
|
struct device *dev = &evt->rc->uwb_dev.dev;
|
|
struct uwb_rc_evt_bpoie_change *bpoiec;
|
|
struct uwb_ie_bpo *bpoie;
|
|
static unsigned count; /* FIXME: this is a temp hack */
|
|
size_t iesize;
|
|
|
|
/* Is there enough data to decode it? */
|
|
if (evt->notif.size < sizeof(*bpoiec)) {
|
|
dev_err(dev, "BPOIEC notification: Not enough data to "
|
|
"decode (%zu vs %zu bytes needed)\n",
|
|
evt->notif.size, sizeof(*bpoiec));
|
|
goto error;
|
|
}
|
|
bpoiec = container_of(evt->notif.rceb, struct uwb_rc_evt_bpoie_change, rceb);
|
|
iesize = le16_to_cpu(bpoiec->wBPOIELength);
|
|
if (iesize < sizeof(*bpoie)) {
|
|
dev_err(dev, "BPOIEC notification: Not enough IE data to "
|
|
"decode (%zu vs %zu bytes needed)\n",
|
|
iesize, sizeof(*bpoie));
|
|
goto error;
|
|
}
|
|
if (++count % 1000 == 0) /* Lame placeholder */
|
|
dev_info(dev, "BPOIE: %u changes received\n", count);
|
|
/*
|
|
* FIXME: At this point we should go over all the IEs in the
|
|
* bpoiec->BPOIE array and act on each.
|
|
*/
|
|
result = 0;
|
|
error:
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Print beaconing state.
|
|
*/
|
|
static ssize_t uwb_rc_beacon_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct uwb_dev *uwb_dev = to_uwb_dev(dev);
|
|
struct uwb_rc *rc = uwb_dev->rc;
|
|
ssize_t result;
|
|
|
|
mutex_lock(&rc->uwb_dev.mutex);
|
|
result = sprintf(buf, "%d\n", rc->beaconing);
|
|
mutex_unlock(&rc->uwb_dev.mutex);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* Start beaconing on the specified channel, or stop beaconing.
|
|
*/
|
|
static ssize_t uwb_rc_beacon_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t size)
|
|
{
|
|
struct uwb_dev *uwb_dev = to_uwb_dev(dev);
|
|
struct uwb_rc *rc = uwb_dev->rc;
|
|
int channel;
|
|
ssize_t result = -EINVAL;
|
|
|
|
result = sscanf(buf, "%d", &channel);
|
|
if (result >= 1)
|
|
result = uwb_radio_force_channel(rc, channel);
|
|
|
|
return result < 0 ? result : size;
|
|
}
|
|
DEVICE_ATTR(beacon, S_IRUGO | S_IWUSR, uwb_rc_beacon_show, uwb_rc_beacon_store);
|