kernel-ark/drivers/uwb/wlp/wlp-lc.c
Tejun Heo 5a0e3ad6af include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
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>
2010-03-30 22:02:32 +09:00

561 lines
15 KiB
C

/*
* WiMedia Logical Link Control Protocol (WLP)
*
* Copyright (C) 2005-2006 Intel Corporation
* Reinette Chatre <reinette.chatre@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/wlp.h>
#include <linux/slab.h>
#include "wlp-internal.h"
static
void wlp_neighbor_init(struct wlp_neighbor_e *neighbor)
{
INIT_LIST_HEAD(&neighbor->wssid);
}
/**
* Create area for device information storage
*
* wlp->mutex must be held
*/
int __wlp_alloc_device_info(struct wlp *wlp)
{
struct device *dev = &wlp->rc->uwb_dev.dev;
BUG_ON(wlp->dev_info != NULL);
wlp->dev_info = kzalloc(sizeof(struct wlp_device_info), GFP_KERNEL);
if (wlp->dev_info == NULL) {
dev_err(dev, "WLP: Unable to allocate memory for "
"device information.\n");
return -ENOMEM;
}
return 0;
}
/**
* Fill in device information using function provided by driver
*
* wlp->mutex must be held
*/
static
void __wlp_fill_device_info(struct wlp *wlp)
{
wlp->fill_device_info(wlp, wlp->dev_info);
}
/**
* Setup device information
*
* Allocate area for device information and populate it.
*
* wlp->mutex must be held
*/
int __wlp_setup_device_info(struct wlp *wlp)
{
int result;
struct device *dev = &wlp->rc->uwb_dev.dev;
result = __wlp_alloc_device_info(wlp);
if (result < 0) {
dev_err(dev, "WLP: Unable to allocate area for "
"device information.\n");
return result;
}
__wlp_fill_device_info(wlp);
return 0;
}
/**
* Remove information about neighbor stored temporarily
*
* Information learned during discovey should only be stored when the
* device enrolls in the neighbor's WSS. We do need to store this
* information temporarily in order to present it to the user.
*
* We are only interested in keeping neighbor WSS information if that
* neighbor is accepting enrollment.
*
* should be called with wlp->nbmutex held
*/
void wlp_remove_neighbor_tmp_info(struct wlp_neighbor_e *neighbor)
{
struct wlp_wssid_e *wssid_e, *next;
u8 keep;
if (!list_empty(&neighbor->wssid)) {
list_for_each_entry_safe(wssid_e, next, &neighbor->wssid,
node) {
if (wssid_e->info != NULL) {
keep = wssid_e->info->accept_enroll;
kfree(wssid_e->info);
wssid_e->info = NULL;
if (!keep) {
list_del(&wssid_e->node);
kfree(wssid_e);
}
}
}
}
if (neighbor->info != NULL) {
kfree(neighbor->info);
neighbor->info = NULL;
}
}
/*
* Populate WLP neighborhood cache with neighbor information
*
* A new neighbor is found. If it is discoverable then we add it to the
* neighborhood cache.
*
*/
static
int wlp_add_neighbor(struct wlp *wlp, struct uwb_dev *dev)
{
int result = 0;
int discoverable;
struct wlp_neighbor_e *neighbor;
/*
* FIXME:
* Use contents of WLP IE found in beacon cache to determine if
* neighbor is discoverable.
* The device does not support WLP IE yet so this still needs to be
* done. Until then we assume all devices are discoverable.
*/
discoverable = 1; /* will be changed when FIXME disappears */
if (discoverable) {
/* Add neighbor to cache for discovery */
neighbor = kzalloc(sizeof(*neighbor), GFP_KERNEL);
if (neighbor == NULL) {
dev_err(&dev->dev, "Unable to create memory for "
"new neighbor. \n");
result = -ENOMEM;
goto error_no_mem;
}
wlp_neighbor_init(neighbor);
uwb_dev_get(dev);
neighbor->uwb_dev = dev;
list_add(&neighbor->node, &wlp->neighbors);
}
error_no_mem:
return result;
}
/**
* Remove one neighbor from cache
*/
static
void __wlp_neighbor_release(struct wlp_neighbor_e *neighbor)
{
struct wlp_wssid_e *wssid_e, *next_wssid_e;
list_for_each_entry_safe(wssid_e, next_wssid_e,
&neighbor->wssid, node) {
list_del(&wssid_e->node);
kfree(wssid_e);
}
uwb_dev_put(neighbor->uwb_dev);
list_del(&neighbor->node);
kfree(neighbor);
}
/**
* Clear entire neighborhood cache.
*/
static
void __wlp_neighbors_release(struct wlp *wlp)
{
struct wlp_neighbor_e *neighbor, *next;
if (list_empty(&wlp->neighbors))
return;
list_for_each_entry_safe(neighbor, next, &wlp->neighbors, node) {
__wlp_neighbor_release(neighbor);
}
}
static
void wlp_neighbors_release(struct wlp *wlp)
{
mutex_lock(&wlp->nbmutex);
__wlp_neighbors_release(wlp);
mutex_unlock(&wlp->nbmutex);
}
/**
* Send D1 message to neighbor, receive D2 message
*
* @neighbor: neighbor to which D1 message will be sent
* @wss: if not NULL, it is an enrollment request for this WSS
* @wssid: if wss not NULL, this is the wssid of the WSS in which we
* want to enroll
*
* A D1/D2 exchange is done for one of two reasons: discovery or
* enrollment. If done for discovery the D1 message is sent to the neighbor
* and the contents of the D2 response is stored in a temporary cache.
* If done for enrollment the @wss and @wssid are provided also. In this
* case the D1 message is sent to the neighbor, the D2 response is parsed
* for enrollment of the WSS with wssid.
*
* &wss->mutex is held
*/
static
int wlp_d1d2_exchange(struct wlp *wlp, struct wlp_neighbor_e *neighbor,
struct wlp_wss *wss, struct wlp_uuid *wssid)
{
int result;
struct device *dev = &wlp->rc->uwb_dev.dev;
DECLARE_COMPLETION_ONSTACK(completion);
struct wlp_session session;
struct sk_buff *skb;
struct wlp_frame_assoc *resp;
struct uwb_dev_addr *dev_addr = &neighbor->uwb_dev->dev_addr;
mutex_lock(&wlp->mutex);
if (!wlp_uuid_is_set(&wlp->uuid)) {
dev_err(dev, "WLP: UUID is not set. Set via sysfs to "
"proceed.\n");
result = -ENXIO;
goto out;
}
/* Send D1 association frame */
result = wlp_send_assoc_frame(wlp, wss, dev_addr, WLP_ASSOC_D1);
if (result < 0) {
dev_err(dev, "Unable to send D1 frame to neighbor "
"%02x:%02x (%d)\n", dev_addr->data[1],
dev_addr->data[0], result);
goto out;
}
/* Create session, wait for response */
session.exp_message = WLP_ASSOC_D2;
session.cb = wlp_session_cb;
session.cb_priv = &completion;
session.neighbor_addr = *dev_addr;
BUG_ON(wlp->session != NULL);
wlp->session = &session;
/* Wait for D2/F0 frame */
result = wait_for_completion_interruptible_timeout(&completion,
WLP_PER_MSG_TIMEOUT * HZ);
if (result == 0) {
result = -ETIMEDOUT;
dev_err(dev, "Timeout while sending D1 to neighbor "
"%02x:%02x.\n", dev_addr->data[1],
dev_addr->data[0]);
goto error_session;
}
if (result < 0) {
dev_err(dev, "Unable to discover/enroll neighbor %02x:%02x.\n",
dev_addr->data[1], dev_addr->data[0]);
goto error_session;
}
/* Parse message in session->data: it will be either D2 or F0 */
skb = session.data;
resp = (void *) skb->data;
if (resp->type == WLP_ASSOC_F0) {
result = wlp_parse_f0(wlp, skb);
if (result < 0)
dev_err(dev, "WLP: Unable to parse F0 from neighbor "
"%02x:%02x.\n", dev_addr->data[1],
dev_addr->data[0]);
result = -EINVAL;
goto error_resp_parse;
}
if (wss == NULL) {
/* Discovery */
result = wlp_parse_d2_frame_to_cache(wlp, skb, neighbor);
if (result < 0) {
dev_err(dev, "WLP: Unable to parse D2 message from "
"neighbor %02x:%02x for discovery.\n",
dev_addr->data[1], dev_addr->data[0]);
goto error_resp_parse;
}
} else {
/* Enrollment */
result = wlp_parse_d2_frame_to_enroll(wss, skb, neighbor,
wssid);
if (result < 0) {
dev_err(dev, "WLP: Unable to parse D2 message from "
"neighbor %02x:%02x for enrollment.\n",
dev_addr->data[1], dev_addr->data[0]);
goto error_resp_parse;
}
}
error_resp_parse:
kfree_skb(skb);
error_session:
wlp->session = NULL;
out:
mutex_unlock(&wlp->mutex);
return result;
}
/**
* Enroll into WSS of provided WSSID by using neighbor as registrar
*
* &wss->mutex is held
*/
int wlp_enroll_neighbor(struct wlp *wlp, struct wlp_neighbor_e *neighbor,
struct wlp_wss *wss, struct wlp_uuid *wssid)
{
int result = 0;
struct device *dev = &wlp->rc->uwb_dev.dev;
char buf[WLP_WSS_UUID_STRSIZE];
struct uwb_dev_addr *dev_addr = &neighbor->uwb_dev->dev_addr;
wlp_wss_uuid_print(buf, sizeof(buf), wssid);
result = wlp_d1d2_exchange(wlp, neighbor, wss, wssid);
if (result < 0) {
dev_err(dev, "WLP: D1/D2 message exchange for enrollment "
"failed. result = %d \n", result);
goto out;
}
if (wss->state != WLP_WSS_STATE_PART_ENROLLED) {
dev_err(dev, "WLP: Unable to enroll into WSS %s using "
"neighbor %02x:%02x. \n", buf,
dev_addr->data[1], dev_addr->data[0]);
result = -EINVAL;
goto out;
}
if (wss->secure_status == WLP_WSS_SECURE) {
dev_err(dev, "FIXME: need to complete secure enrollment.\n");
result = -EINVAL;
goto error;
} else {
wss->state = WLP_WSS_STATE_ENROLLED;
dev_dbg(dev, "WLP: Success Enrollment into unsecure WSS "
"%s using neighbor %02x:%02x. \n",
buf, dev_addr->data[1], dev_addr->data[0]);
}
out:
return result;
error:
wlp_wss_reset(wss);
return result;
}
/**
* Discover WSS information of neighbor's active WSS
*/
static
int wlp_discover_neighbor(struct wlp *wlp,
struct wlp_neighbor_e *neighbor)
{
return wlp_d1d2_exchange(wlp, neighbor, NULL, NULL);
}
/**
* Each neighbor in the neighborhood cache is discoverable. Discover it.
*
* Discovery is done through sending of D1 association frame and parsing
* the D2 association frame response. Only wssid from D2 will be included
* in neighbor cache, rest is just displayed to user and forgotten.
*
* The discovery is not done in parallel. This is simple and enables us to
* maintain only one association context.
*
* The discovery of one neighbor does not affect the other, but if the
* discovery of a neighbor fails it is removed from the neighborhood cache.
*/
static
int wlp_discover_all_neighbors(struct wlp *wlp)
{
int result = 0;
struct device *dev = &wlp->rc->uwb_dev.dev;
struct wlp_neighbor_e *neighbor, *next;
list_for_each_entry_safe(neighbor, next, &wlp->neighbors, node) {
result = wlp_discover_neighbor(wlp, neighbor);
if (result < 0) {
dev_err(dev, "WLP: Unable to discover neighbor "
"%02x:%02x, removing from neighborhood. \n",
neighbor->uwb_dev->dev_addr.data[1],
neighbor->uwb_dev->dev_addr.data[0]);
__wlp_neighbor_release(neighbor);
}
}
return result;
}
static int wlp_add_neighbor_helper(struct device *dev, void *priv)
{
struct wlp *wlp = priv;
struct uwb_dev *uwb_dev = to_uwb_dev(dev);
return wlp_add_neighbor(wlp, uwb_dev);
}
/**
* Discover WLP neighborhood
*
* Will send D1 association frame to all devices in beacon group that have
* discoverable bit set in WLP IE. D2 frames will be received, information
* displayed to user in @buf. Partial information (from D2 association
* frame) will be cached to assist with future association
* requests.
*
* The discovery of the WLP neighborhood is triggered by the user. This
* should occur infrequently and we thus free current cache and re-allocate
* memory if needed.
*
* If one neighbor fails during initial discovery (determining if it is a
* neighbor or not), we fail all - note that interaction with neighbor has
* not occured at this point so if a failure occurs we know something went wrong
* locally. We thus undo everything.
*/
ssize_t wlp_discover(struct wlp *wlp)
{
int result = 0;
struct device *dev = &wlp->rc->uwb_dev.dev;
mutex_lock(&wlp->nbmutex);
/* Clear current neighborhood cache. */
__wlp_neighbors_release(wlp);
/* Determine which devices in neighborhood. Repopulate cache. */
result = uwb_dev_for_each(wlp->rc, wlp_add_neighbor_helper, wlp);
if (result < 0) {
/* May have partial neighbor information, release all. */
__wlp_neighbors_release(wlp);
goto error_dev_for_each;
}
/* Discover the properties of devices in neighborhood. */
result = wlp_discover_all_neighbors(wlp);
/* In case of failure we still print our partial results. */
if (result < 0) {
dev_err(dev, "Unable to fully discover neighborhood. \n");
result = 0;
}
error_dev_for_each:
mutex_unlock(&wlp->nbmutex);
return result;
}
/**
* Handle events from UWB stack
*
* We handle events conservatively. If a neighbor goes off the air we
* remove it from the neighborhood. If an association process is in
* progress this function will block waiting for the nbmutex to become
* free. The association process will thus be allowed to complete before it
* is removed.
*/
static
void wlp_uwb_notifs_cb(void *_wlp, struct uwb_dev *uwb_dev,
enum uwb_notifs event)
{
struct wlp *wlp = _wlp;
struct device *dev = &wlp->rc->uwb_dev.dev;
struct wlp_neighbor_e *neighbor, *next;
int result;
switch (event) {
case UWB_NOTIF_ONAIR:
result = wlp_eda_create_node(&wlp->eda,
uwb_dev->mac_addr.data,
&uwb_dev->dev_addr);
if (result < 0)
dev_err(dev, "WLP: Unable to add new neighbor "
"%02x:%02x to EDA cache.\n",
uwb_dev->dev_addr.data[1],
uwb_dev->dev_addr.data[0]);
break;
case UWB_NOTIF_OFFAIR:
wlp_eda_rm_node(&wlp->eda, &uwb_dev->dev_addr);
mutex_lock(&wlp->nbmutex);
list_for_each_entry_safe(neighbor, next, &wlp->neighbors, node) {
if (neighbor->uwb_dev == uwb_dev)
__wlp_neighbor_release(neighbor);
}
mutex_unlock(&wlp->nbmutex);
break;
default:
dev_err(dev, "don't know how to handle event %d from uwb\n",
event);
}
}
static void wlp_channel_changed(struct uwb_pal *pal, int channel)
{
struct wlp *wlp = container_of(pal, struct wlp, pal);
if (channel < 0)
netif_carrier_off(wlp->ndev);
else
netif_carrier_on(wlp->ndev);
}
int wlp_setup(struct wlp *wlp, struct uwb_rc *rc, struct net_device *ndev)
{
int result;
BUG_ON(wlp->fill_device_info == NULL);
BUG_ON(wlp->xmit_frame == NULL);
BUG_ON(wlp->stop_queue == NULL);
BUG_ON(wlp->start_queue == NULL);
wlp->rc = rc;
wlp->ndev = ndev;
wlp_eda_init(&wlp->eda);/* Set up address cache */
wlp->uwb_notifs_handler.cb = wlp_uwb_notifs_cb;
wlp->uwb_notifs_handler.data = wlp;
uwb_notifs_register(rc, &wlp->uwb_notifs_handler);
uwb_pal_init(&wlp->pal);
wlp->pal.rc = rc;
wlp->pal.channel_changed = wlp_channel_changed;
result = uwb_pal_register(&wlp->pal);
if (result < 0)
uwb_notifs_deregister(wlp->rc, &wlp->uwb_notifs_handler);
return result;
}
EXPORT_SYMBOL_GPL(wlp_setup);
void wlp_remove(struct wlp *wlp)
{
wlp_neighbors_release(wlp);
uwb_pal_unregister(&wlp->pal);
uwb_notifs_deregister(wlp->rc, &wlp->uwb_notifs_handler);
wlp_eda_release(&wlp->eda);
mutex_lock(&wlp->mutex);
if (wlp->dev_info != NULL)
kfree(wlp->dev_info);
mutex_unlock(&wlp->mutex);
wlp->rc = NULL;
}
EXPORT_SYMBOL_GPL(wlp_remove);
/**
* wlp_reset_all - reset the WLP hardware
* @wlp: the WLP device to reset.
*
* This schedules a full hardware reset of the WLP device. The radio
* controller and any other PALs will also be reset.
*/
void wlp_reset_all(struct wlp *wlp)
{
uwb_rc_reset_all(wlp->rc);
}
EXPORT_SYMBOL_GPL(wlp_reset_all);