[deliverable/linux.git] / drivers / uwb / lc-rc.c

/*
 * Ultra Wide Band
 * Life cycle of radio controllers
 *
 * 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
 *
 * A UWB radio controller is also a UWB device, so it embeds one...
 *
 * List of RCs comes from the 'struct class uwb_rc_class'.
 */

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/random.h>
#include <linux/kdev_t.h>
#include <linux/etherdevice.h>
#include <linux/usb.h>

#include "uwb-internal.h"

static int uwb_rc_index_match(struct device *dev, void *data)
{
	int *index = data;
	struct uwb_rc *rc = dev_get_drvdata(dev);

	if (rc->index == *index)
		return 1;
	return 0;
}

static struct uwb_rc *uwb_rc_find_by_index(int index)
{
	struct device *dev;
	struct uwb_rc *rc = NULL;

	dev = class_find_device(&uwb_rc_class, NULL, &index, uwb_rc_index_match);
	if (dev)
		rc = dev_get_drvdata(dev);
	return rc;
}

static int uwb_rc_new_index(void)
{
	int index = 0;

	for (;;) {
		if (!uwb_rc_find_by_index(index))
			return index;
		if (++index < 0)
			index = 0;
	}
}

/**
 * Release the backing device of a uwb_rc that has been dynamically allocated.
 */
static void uwb_rc_sys_release(struct device *dev)
{
	struct uwb_dev *uwb_dev = container_of(dev, struct uwb_dev, dev);
	struct uwb_rc *rc = container_of(uwb_dev, struct uwb_rc, uwb_dev);

	uwb_rc_neh_destroy(rc);
	uwb_rc_ie_release(rc);
	kfree(rc);
}


void uwb_rc_init(struct uwb_rc *rc)
{
	struct uwb_dev *uwb_dev = &rc->uwb_dev;

	uwb_dev_init(uwb_dev);
	rc->uwb_dev.dev.class = &uwb_rc_class;
	rc->uwb_dev.dev.release = uwb_rc_sys_release;
	uwb_rc_neh_create(rc);
	rc->beaconing = -1;
	rc->scan_type = UWB_SCAN_DISABLED;
	INIT_LIST_HEAD(&rc->notifs_chain.list);
	mutex_init(&rc->notifs_chain.mutex);
	INIT_LIST_HEAD(&rc->uwb_beca.list);
	mutex_init(&rc->uwb_beca.mutex);
	uwb_drp_avail_init(rc);
	uwb_rc_ie_init(rc);
	uwb_rsv_init(rc);
	uwb_rc_pal_init(rc);
}
EXPORT_SYMBOL_GPL(uwb_rc_init);


struct uwb_rc *uwb_rc_alloc(void)
{
	struct uwb_rc *rc;
	rc = kzalloc(sizeof(*rc), GFP_KERNEL);
	if (rc == NULL)
		return NULL;
	uwb_rc_init(rc);
	return rc;
}
EXPORT_SYMBOL_GPL(uwb_rc_alloc);

static struct attribute *rc_attrs[] = {
		&dev_attr_mac_address.attr,
		&dev_attr_scan.attr,
		&dev_attr_beacon.attr,
		NULL,
};

static struct attribute_group rc_attr_group = {
	.attrs = rc_attrs,
};

/*
 * Registration of sysfs specific stuff
 */
static int uwb_rc_sys_add(struct uwb_rc *rc)
{
	return sysfs_create_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
}


static void __uwb_rc_sys_rm(struct uwb_rc *rc)
{
	sysfs_remove_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
}

/**
 * uwb_rc_mac_addr_setup - get an RC's EUI-48 address or set it
 * @rc:  the radio controller.
 *
 * If the EUI-48 address is 00:00:00:00:00:00 or FF:FF:FF:FF:FF:FF
 * then a random locally administered EUI-48 is generated and set on
 * the device.  The probability of address collisions is sufficiently
 * unlikely (1/2^40 = 9.1e-13) that they're not checked for.
 */
static
int uwb_rc_mac_addr_setup(struct uwb_rc *rc)
{
	int result;
	struct device *dev = &rc->uwb_dev.dev;
	struct uwb_dev *uwb_dev = &rc->uwb_dev;
	char devname[UWB_ADDR_STRSIZE];
	struct uwb_mac_addr addr;

	result = uwb_rc_mac_addr_get(rc, &addr);
	if (result < 0) {
		dev_err(dev, "cannot retrieve UWB EUI-48 address: %d\n", result);
		return result;
	}

	if (uwb_mac_addr_unset(&addr) || uwb_mac_addr_bcast(&addr)) {
		addr.data[0] = 0x02; /* locally adminstered and unicast */
		get_random_bytes(&addr.data[1], sizeof(addr.data)-1);

		result = uwb_rc_mac_addr_set(rc, &addr);
		if (result < 0) {
			uwb_mac_addr_print(devname, sizeof(devname), &addr);
			dev_err(dev, "cannot set EUI-48 address %s: %d\n",
				devname, result);
			return result;
		}
	}
	uwb_dev->mac_addr = addr;
	return 0;
}


static int uwb_rc_setup(struct uwb_rc *rc)
{
	int result;
	struct device *dev = &rc->uwb_dev.dev;

	result = uwb_rc_reset(rc);
	if (result < 0) {
		dev_err(dev, "cannot reset UWB radio: %d\n", result);
		goto error;
	}
	result = uwb_rc_mac_addr_setup(rc);
	if (result < 0) {
		dev_err(dev, "cannot setup UWB MAC address: %d\n", result);
		goto error;
	}
	result = uwb_rc_dev_addr_assign(rc);
	if (result < 0) {
		dev_err(dev, "cannot assign UWB DevAddr: %d\n", result);
		goto error;
	}
	result = uwb_rc_ie_setup(rc);
	if (result < 0) {
		dev_err(dev, "cannot setup IE subsystem: %d\n", result);
		goto error_ie_setup;
	}
	result = uwb_rsv_setup(rc);
	if (result < 0) {
		dev_err(dev, "cannot setup reservation subsystem: %d\n", result);
		goto error_rsv_setup;
	}
	uwb_dbg_add_rc(rc);
	return 0;

error_rsv_setup:
	uwb_rc_ie_release(rc);
error_ie_setup:
error:
	return result;
}


/**
 * Register a new UWB radio controller
 *
 * Did you call uwb_rc_init() on your rc?
 *
 * We assume that this is being called with a > 0 refcount on
 * it [through ops->{get|put}_device(). We'll take our own, though.
 *
 * @parent_dev is our real device, the one that provides the actual UWB device
 */
int uwb_rc_add(struct uwb_rc *rc, struct device *parent_dev, void *priv)
{
	int result;
	struct device *dev;
	char macbuf[UWB_ADDR_STRSIZE], devbuf[UWB_ADDR_STRSIZE];

	rc->index = uwb_rc_new_index();

	dev = &rc->uwb_dev.dev;
	dev_set_name(dev, "uwb%d", rc->index);

	rc->priv = priv;

	init_waitqueue_head(&rc->uwbd.wq);
	INIT_LIST_HEAD(&rc->uwbd.event_list);
	spin_lock_init(&rc->uwbd.event_list_lock);

	uwbd_start(rc);

	result = rc->start(rc);
	if (result < 0)
		goto error_rc_start;

	result = uwb_rc_setup(rc);
	if (result < 0) {
		dev_err(dev, "cannot setup UWB radio controller: %d\n", result);
		goto error_rc_setup;
	}

	result = uwb_dev_add(&rc->uwb_dev, parent_dev, rc);
	if (result < 0 && result != -EADDRNOTAVAIL)
		goto error_dev_add;

	result = uwb_rc_sys_add(rc);
	if (result < 0) {
		dev_err(parent_dev, "cannot register UWB radio controller "
			"dev attributes: %d\n", result);
		goto error_sys_add;
	}

	uwb_mac_addr_print(macbuf, sizeof(macbuf), &rc->uwb_dev.mac_addr);
	uwb_dev_addr_print(devbuf, sizeof(devbuf), &rc->uwb_dev.dev_addr);
	dev_info(dev,
		 "new uwb radio controller (mac %s dev %s) on %s %s\n",
		 macbuf, devbuf, parent_dev->bus->name, dev_name(parent_dev));
	rc->ready = 1;
	return 0;

error_sys_add:
	uwb_dev_rm(&rc->uwb_dev);
error_dev_add:
error_rc_setup:
	rc->stop(rc);
	uwbd_stop(rc);
error_rc_start:
	return result;
}
EXPORT_SYMBOL_GPL(uwb_rc_add);


static int uwb_dev_offair_helper(struct device *dev, void *priv)
{
	struct uwb_dev *uwb_dev = to_uwb_dev(dev);

	return __uwb_dev_offair(uwb_dev, uwb_dev->rc);
}

/*
 * Remove a Radio Controller; stop beaconing/scanning, disconnect all children
 */
void uwb_rc_rm(struct uwb_rc *rc)
{
	rc->ready = 0;

	uwb_dbg_del_rc(rc);
	uwb_rsv_cleanup(rc);
	uwb_rc_ie_rm(rc, UWB_IDENTIFICATION_IE);
	if (rc->beaconing >= 0)
		uwb_rc_beacon(rc, -1, 0);
	if (rc->scan_type != UWB_SCAN_DISABLED)
		uwb_rc_scan(rc, rc->scanning, UWB_SCAN_DISABLED, 0);
	uwb_rc_reset(rc);

	rc->stop(rc);

	uwbd_stop(rc);

	uwb_dev_lock(&rc->uwb_dev);
	rc->priv = NULL;
	rc->cmd = NULL;
	uwb_dev_unlock(&rc->uwb_dev);
	mutex_lock(&rc->uwb_beca.mutex);
	uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
	__uwb_rc_sys_rm(rc);
	mutex_unlock(&rc->uwb_beca.mutex);
 	uwb_beca_release(rc);
	uwb_dev_rm(&rc->uwb_dev);
}
EXPORT_SYMBOL_GPL(uwb_rc_rm);

static int find_rc_try_get(struct device *dev, void *data)
{
	struct uwb_rc *target_rc = data;
	struct uwb_rc *rc = dev_get_drvdata(dev);

	if (rc == NULL) {
		WARN_ON(1);
		return 0;
	}
	if (rc == target_rc) {
		if (rc->ready == 0)
			return 0;
		else
			return 1;
	}
	return 0;
}

/**
 * Given a radio controller descriptor, validate and refcount it
 *
 * @returns NULL if the rc does not exist or is quiescing; the ptr to
 *               it otherwise.
 */
struct uwb_rc *__uwb_rc_try_get(struct uwb_rc *target_rc)
{
	struct device *dev;
	struct uwb_rc *rc = NULL;

	dev = class_find_device(&uwb_rc_class, NULL, target_rc,
				find_rc_try_get);
	if (dev) {
		rc = dev_get_drvdata(dev);
		__uwb_rc_get(rc);
	}
	return rc;
}
EXPORT_SYMBOL_GPL(__uwb_rc_try_get);

/*
 * RC get for external refcount acquirers...
 *
 * Increments the refcount of the device and it's backend modules
 */
static inline struct uwb_rc *uwb_rc_get(struct uwb_rc *rc)
{
	if (rc->ready == 0)
		return NULL;
	uwb_dev_get(&rc->uwb_dev);
	return rc;
}

static int find_rc_grandpa(struct device *dev, void *data)
{
	struct device *grandpa_dev = data;
	struct uwb_rc *rc = dev_get_drvdata(dev);

	if (rc->uwb_dev.dev.parent->parent == grandpa_dev) {
		rc = uwb_rc_get(rc);
		return 1;
	}
	return 0;
}

/**
 * Locate and refcount a radio controller given a common grand-parent
 *
 * @grandpa_dev  Pointer to the 'grandparent' device structure.
 * @returns NULL If the rc does not exist or is quiescing; the ptr to
 *               it otherwise, properly referenced.
 *
 * The Radio Control interface (or the UWB Radio Controller) is always
 * an interface of a device. The parent is the interface, the
 * grandparent is the device that encapsulates the interface.
 *
 * There is no need to lock around as the "grandpa" would be
 * refcounted by the target, and to remove the referemes, the
 * uwb_rc_class->sem would have to be taken--we hold it, ergo we
 * should be safe.
 */
struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *grandpa_dev)
{
	struct device *dev;
	struct uwb_rc *rc = NULL;

	dev = class_find_device(&uwb_rc_class, NULL, (void *)grandpa_dev,
				find_rc_grandpa);
	if (dev)
		rc = dev_get_drvdata(dev);
	return rc;
}
EXPORT_SYMBOL_GPL(uwb_rc_get_by_grandpa);

/**
 * Find a radio controller by device address
 *
 * @returns the pointer to the radio controller, properly referenced
 */
static int find_rc_dev(struct device *dev, void *data)
{
	struct uwb_dev_addr *addr = data;
	struct uwb_rc *rc = dev_get_drvdata(dev);

	if (rc == NULL) {
		WARN_ON(1);
		return 0;
	}
	if (!uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, addr)) {
		rc = uwb_rc_get(rc);
		return 1;
	}
	return 0;
}

struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *addr)
{
	struct device *dev;
	struct uwb_rc *rc = NULL;

	dev = class_find_device(&uwb_rc_class, NULL, (void *)addr,
				find_rc_dev);
	if (dev)
		rc = dev_get_drvdata(dev);

	return rc;
}
EXPORT_SYMBOL_GPL(uwb_rc_get_by_dev);

/**
 * Drop a reference on a radio controller
 *
 * This is the version that should be done by entities external to the
 * UWB Radio Control stack (ie: clients of the API).
 */
void uwb_rc_put(struct uwb_rc *rc)
{
	__uwb_rc_put(rc);
}
EXPORT_SYMBOL_GPL(uwb_rc_put);
Commit	Line	Data
183b9b59 IPG	1	/*
	2	* Ultra Wide Band
	3	* Life cycle of radio controllers
	4	*
	5	* Copyright (C) 2005-2006 Intel Corporation
	6	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	7	*
	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.
	11	*
	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.
	16	*
	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
	20	* 02110-1301, USA.
	21	*
	22	*
	23	* FIXME: docs
	24	*
	25	* A UWB radio controller is also a UWB device, so it embeds one...
	26	*
	27	* List of RCs comes from the 'struct class uwb_rc_class'.
	28	*/
	29
	30	#include <linux/kernel.h>
	31	#include <linux/string.h>
	32	#include <linux/device.h>
	33	#include <linux/err.h>
	34	#include <linux/random.h>
	35	#include <linux/kdev_t.h>
	36	#include <linux/etherdevice.h>
	37	#include <linux/usb.h>
	38
183b9b59 IPG	39	#include "uwb-internal.h"
	40
	41	static int uwb_rc_index_match(struct device dev, void data)
	42	{
	43	int *index = data;
	44	struct uwb_rc *rc = dev_get_drvdata(dev);
	45
	46	if (rc->index == *index)
	47	return 1;
	48	return 0;
	49	}
	50
	51	static struct uwb_rc *uwb_rc_find_by_index(int index)
	52	{
	53	struct device *dev;
	54	struct uwb_rc *rc = NULL;
	55
	56	dev = class_find_device(&uwb_rc_class, NULL, &index, uwb_rc_index_match);
	57	if (dev)
	58	rc = dev_get_drvdata(dev);
	59	return rc;
	60	}
	61
	62	static int uwb_rc_new_index(void)
	63	{
	64	int index = 0;
	65
	66	for (;;) {
	67	if (!uwb_rc_find_by_index(index))
	68	return index;
	69	if (++index < 0)
	70	index = 0;
	71	}
	72	}
	73
	74	/**
	75	* Release the backing device of a uwb_rc that has been dynamically allocated.
	76	*/
	77	static void uwb_rc_sys_release(struct device *dev)
	78	{
	79	struct uwb_dev *uwb_dev = container_of(dev, struct uwb_dev, dev);
	80	struct uwb_rc *rc = container_of(uwb_dev, struct uwb_rc, uwb_dev);
	81
	82	uwb_rc_neh_destroy(rc);
	83	uwb_rc_ie_release(rc);
183b9b59 IPG	84	kfree(rc);
	85	}
	86
	87
	88	void uwb_rc_init(struct uwb_rc *rc)
	89	{
	90	struct uwb_dev *uwb_dev = &rc->uwb_dev;
	91
	92	uwb_dev_init(uwb_dev);
	93	rc->uwb_dev.dev.class = &uwb_rc_class;
	94	rc->uwb_dev.dev.release = uwb_rc_sys_release;
	95	uwb_rc_neh_create(rc);
	96	rc->beaconing = -1;
	97	rc->scan_type = UWB_SCAN_DISABLED;
	98	INIT_LIST_HEAD(&rc->notifs_chain.list);
	99	mutex_init(&rc->notifs_chain.mutex);
fec1a593 SP	100	INIT_LIST_HEAD(&rc->uwb_beca.list);
fec1a593 SP	101	mutex_init(&rc->uwb_beca.mutex);
183b9b59 IPG	102	uwb_drp_avail_init(rc);
	103	uwb_rc_ie_init(rc);
	104	uwb_rsv_init(rc);
	105	uwb_rc_pal_init(rc);
	106	}
	107	EXPORT_SYMBOL_GPL(uwb_rc_init);
	108
	109
	110	struct uwb_rc *uwb_rc_alloc(void)
	111	{
	112	struct uwb_rc *rc;
	113	rc = kzalloc(sizeof(*rc), GFP_KERNEL);
	114	if (rc == NULL)
	115	return NULL;
	116	uwb_rc_init(rc);
	117	return rc;
	118	}
	119	EXPORT_SYMBOL_GPL(uwb_rc_alloc);
	120
	121	static struct attribute *rc_attrs[] = {
	122	&dev_attr_mac_address.attr,
	123	&dev_attr_scan.attr,
	124	&dev_attr_beacon.attr,
	125	NULL,
	126	};
	127
	128	static struct attribute_group rc_attr_group = {
	129	.attrs = rc_attrs,
	130	};
	131
	132	/*
	133	* Registration of sysfs specific stuff
	134	*/
	135	static int uwb_rc_sys_add(struct uwb_rc *rc)
	136	{
	137	return sysfs_create_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
	138	}
	139
	140
	141	static void __uwb_rc_sys_rm(struct uwb_rc *rc)
	142	{
	143	sysfs_remove_group(&rc->uwb_dev.dev.kobj, &rc_attr_group);
	144	}
	145
	146	/**
	147	* uwb_rc_mac_addr_setup - get an RC's EUI-48 address or set it
	148	* @rc: the radio controller.
	149	*
	150	* If the EUI-48 address is 00:00:00:00:00:00 or FF:FF:FF:FF:FF:FF
	151	* then a random locally administered EUI-48 is generated and set on
	152	* the device. The probability of address collisions is sufficiently
	153	* unlikely (1/2^40 = 9.1e-13) that they're not checked for.
	154	*/
	155	static
	156	int uwb_rc_mac_addr_setup(struct uwb_rc *rc)
	157	{
	158	int result;
	159	struct device *dev = &rc->uwb_dev.dev;
	160	struct uwb_dev *uwb_dev = &rc->uwb_dev;
	161	char devname[UWB_ADDR_STRSIZE];
	162	struct uwb_mac_addr addr;
	163
	164	result = uwb_rc_mac_addr_get(rc, &addr);
	165	if (result < 0) {
166	dev_err(dev, "cannot retrieve UWB EUI-48 address: %d\n", result);
167	return result;
168	}
169
170	if (uwb_mac_addr_unset(&addr) \|\| uwb_mac_addr_bcast(&addr)) {
171	addr.data[0] = 0x02; /* locally adminstered and unicast */
172	get_random_bytes(&addr.data[1], sizeof(addr.data)-1);
173
174	result = uwb_rc_mac_addr_set(rc, &addr);
175	if (result < 0) {
176	uwb_mac_addr_print(devname, sizeof(devname), &addr);
177	dev_err(dev, "cannot set EUI-48 address %s: %d\n",
178	devname, result);
179	return result;
180	}
181	}
182	uwb_dev->mac_addr = addr;
183	return 0;
184	}
185
186
187
188	static int uwb_rc_setup(struct uwb_rc *rc)
189	{
190	int result;
191	struct device *dev = &rc->uwb_dev.dev;
192
193	result = uwb_rc_reset(rc);
194	if (result < 0) {
195	dev_err(dev, "cannot reset UWB radio: %d\n", result);
196	goto error;
197	}
198	result = uwb_rc_mac_addr_setup(rc);
199	if (result < 0) {
200	dev_err(dev, "cannot setup UWB MAC address: %d\n", result);
201	goto error;
202	}
203	result = uwb_rc_dev_addr_assign(rc);
204	if (result < 0) {
205	dev_err(dev, "cannot assign UWB DevAddr: %d\n", result);
206	goto error;
207	}
208	result = uwb_rc_ie_setup(rc);
209	if (result < 0) {
210	dev_err(dev, "cannot setup IE subsystem: %d\n", result);
211	goto error_ie_setup;
212	}
183b9b59 IPG	213	result = uwb_rsv_setup(rc);
	214	if (result < 0) {
	215	dev_err(dev, "cannot setup reservation subsystem: %d\n", result);
	216	goto error_rsv_setup;
	217	}
	218	uwb_dbg_add_rc(rc);
	219	return 0;
	220
	221	error_rsv_setup:
	222	uwb_rc_ie_release(rc);
	223	error_ie_setup:
	224	error:
	225	return result;
	226	}
	227
	228
	229	/**
	230	* Register a new UWB radio controller
	231	*
	232	* Did you call uwb_rc_init() on your rc?
	233	*
	234	* We assume that this is being called with a > 0 refcount on
	235	* it [through ops->{get\|put}_device(). We'll take our own, though.
	236	*
	237	* @parent_dev is our real device, the one that provides the actual UWB device
	238	*/
	239	int uwb_rc_add(struct uwb_rc rc, struct device parent_dev, void *priv)
	240	{
	241	int result;
	242	struct device *dev;
	243	char macbuf[UWB_ADDR_STRSIZE], devbuf[UWB_ADDR_STRSIZE];
	244
	245	rc->index = uwb_rc_new_index();
	246
	247	dev = &rc->uwb_dev.dev;
	248	dev_set_name(dev, "uwb%d", rc->index);
	249
	250	rc->priv = priv;
	251
fec1a593 SP	252	init_waitqueue_head(&rc->uwbd.wq);
	253	INIT_LIST_HEAD(&rc->uwbd.event_list);
	254	spin_lock_init(&rc->uwbd.event_list_lock);
	255
	256	uwbd_start(rc);
	257
183b9b59 IPG	258	result = rc->start(rc);
	259	if (result < 0)
	260	goto error_rc_start;
	261
	262	result = uwb_rc_setup(rc);
	263	if (result < 0) {
	264	dev_err(dev, "cannot setup UWB radio controller: %d\n", result);
	265	goto error_rc_setup;
	266	}
	267
	268	result = uwb_dev_add(&rc->uwb_dev, parent_dev, rc);
	269	if (result < 0 && result != -EADDRNOTAVAIL)
	270	goto error_dev_add;
	271
	272	result = uwb_rc_sys_add(rc);
	273	if (result < 0) {
	274	dev_err(parent_dev, "cannot register UWB radio controller "
	275	"dev attributes: %d\n", result);
	276	goto error_sys_add;
	277	}
	278
	279	uwb_mac_addr_print(macbuf, sizeof(macbuf), &rc->uwb_dev.mac_addr);
	280	uwb_dev_addr_print(devbuf, sizeof(devbuf), &rc->uwb_dev.dev_addr);
	281	dev_info(dev,
	282	"new uwb radio controller (mac %s dev %s) on %s %s\n",
	283	macbuf, devbuf, parent_dev->bus->name, dev_name(parent_dev));
	284	rc->ready = 1;
	285	return 0;
	286
	287	error_sys_add:
	288	uwb_dev_rm(&rc->uwb_dev);
	289	error_dev_add:
	290	error_rc_setup:
	291	rc->stop(rc);
fec1a593	292	uwbd_stop(rc);
183b9b59 IPG	293	error_rc_start:
	294	return result;
	295	}
	296	EXPORT_SYMBOL_GPL(uwb_rc_add);
	297
	298
	299	static int uwb_dev_offair_helper(struct device dev, void priv)
	300	{
	301	struct uwb_dev *uwb_dev = to_uwb_dev(dev);
	302
	303	return __uwb_dev_offair(uwb_dev, uwb_dev->rc);
	304	}
	305
	306	/*
	307	* Remove a Radio Controller; stop beaconing/scanning, disconnect all children
	308	*/
	309	void uwb_rc_rm(struct uwb_rc *rc)
	310	{
	311	rc->ready = 0;
	312
	313	uwb_dbg_del_rc(rc);
	314	uwb_rsv_cleanup(rc);
	315	uwb_rc_ie_rm(rc, UWB_IDENTIFICATION_IE);
	316	if (rc->beaconing >= 0)
	317	uwb_rc_beacon(rc, -1, 0);
	318	if (rc->scan_type != UWB_SCAN_DISABLED)
	319	uwb_rc_scan(rc, rc->scanning, UWB_SCAN_DISABLED, 0);
	320	uwb_rc_reset(rc);
	321
	322	rc->stop(rc);
fec1a593 SP	323
fec1a593 SP	324	uwbd_stop(rc);
183b9b59 IPG	325
	326	uwb_dev_lock(&rc->uwb_dev);
	327	rc->priv = NULL;
	328	rc->cmd = NULL;
	329	uwb_dev_unlock(&rc->uwb_dev);
fec1a593	330	mutex_lock(&rc->uwb_beca.mutex);
183b9b59 IPG	331	uwb_dev_for_each(rc, uwb_dev_offair_helper, NULL);
183b9b59 IPG	332	__uwb_rc_sys_rm(rc);
fec1a593 SP	333	mutex_unlock(&rc->uwb_beca.mutex);
fec1a593 SP	334	uwb_beca_release(rc);
183b9b59 IPG	335	uwb_dev_rm(&rc->uwb_dev);
	336	}
	337	EXPORT_SYMBOL_GPL(uwb_rc_rm);
	338
	339	static int find_rc_try_get(struct device dev, void data)
	340	{
	341	struct uwb_rc *target_rc = data;
	342	struct uwb_rc *rc = dev_get_drvdata(dev);
	343
	344	if (rc == NULL) {
	345	WARN_ON(1);
	346	return 0;
	347	}
	348	if (rc == target_rc) {
	349	if (rc->ready == 0)
	350	return 0;
	351	else
	352	return 1;
	353	}
	354	return 0;
	355	}
	356
	357	/**
	358	* Given a radio controller descriptor, validate and refcount it
	359	*
	360	* @returns NULL if the rc does not exist or is quiescing; the ptr to
	361	* it otherwise.
	362	*/
	363	struct uwb_rc __uwb_rc_try_get(struct uwb_rc target_rc)
	364	{
	365	struct device *dev;
	366	struct uwb_rc *rc = NULL;
	367
	368	dev = class_find_device(&uwb_rc_class, NULL, target_rc,
	369	find_rc_try_get);
	370	if (dev) {
	371	rc = dev_get_drvdata(dev);
	372	__uwb_rc_get(rc);
	373	}
	374	return rc;
	375	}
	376	EXPORT_SYMBOL_GPL(__uwb_rc_try_get);
	377
	378	/*
	379	* RC get for external refcount acquirers...
	380	*
	381	* Increments the refcount of the device and it's backend modules
	382	*/
	383	static inline struct uwb_rc uwb_rc_get(struct uwb_rc rc)
	384	{
	385	if (rc->ready == 0)
	386	return NULL;
	387	uwb_dev_get(&rc->uwb_dev);
	388	return rc;
	389	}
	390
	391	static int find_rc_grandpa(struct device dev, void data)
	392	{
	393	struct device *grandpa_dev = data;
	394	struct uwb_rc *rc = dev_get_drvdata(dev);
	395
	396	if (rc->uwb_dev.dev.parent->parent == grandpa_dev) {
	397	rc = uwb_rc_get(rc);
	398	return 1;
399	}
400	return 0;
401	}
402
403	/**
404	* Locate and refcount a radio controller given a common grand-parent
405	*
406	* @grandpa_dev Pointer to the 'grandparent' device structure.
407	* @returns NULL If the rc does not exist or is quiescing; the ptr to
408	* it otherwise, properly referenced.
409	*
410	* The Radio Control interface (or the UWB Radio Controller) is always
411	* an interface of a device. The parent is the interface, the
412	* grandparent is the device that encapsulates the interface.
413	*
414	* There is no need to lock around as the "grandpa" would be
415	* refcounted by the target, and to remove the referemes, the
416	* uwb_rc_class->sem would have to be taken--we hold it, ergo we
417	* should be safe.
418	*/
419	struct uwb_rc uwb_rc_get_by_grandpa(const struct device grandpa_dev)
420	{
421	struct device *dev;
422	struct uwb_rc *rc = NULL;
423
424	dev = class_find_device(&uwb_rc_class, NULL, (void *)grandpa_dev,
425	find_rc_grandpa);
426	if (dev)
427	rc = dev_get_drvdata(dev);
428	return rc;
429	}
430	EXPORT_SYMBOL_GPL(uwb_rc_get_by_grandpa);
431
432	/**
433	* Find a radio controller by device address
434	*
435	* @returns the pointer to the radio controller, properly referenced
436	*/
437	static int find_rc_dev(struct device dev, void data)
438	{
439	struct uwb_dev_addr *addr = data;
440	struct uwb_rc *rc = dev_get_drvdata(dev);
441
442	if (rc == NULL) {
443	WARN_ON(1);
444	return 0;
445	}
446	if (!uwb_dev_addr_cmp(&rc->uwb_dev.dev_addr, addr)) {
447	rc = uwb_rc_get(rc);
448	return 1;
449	}
450	return 0;
451	}
452
453	struct uwb_rc uwb_rc_get_by_dev(const struct uwb_dev_addr addr)
454	{
455	struct device *dev;
456	struct uwb_rc *rc = NULL;
457
458	dev = class_find_device(&uwb_rc_class, NULL, (void *)addr,
459	find_rc_dev);
460	if (dev)
461	rc = dev_get_drvdata(dev);
462
463	return rc;
464	}
465	EXPORT_SYMBOL_GPL(uwb_rc_get_by_dev);
466
467	/**
468	* Drop a reference on a radio controller
469	*
470	* This is the version that should be done by entities external to the
471	* UWB Radio Control stack (ie: clients of the API).
472	*/
473	void uwb_rc_put(struct uwb_rc *rc)
474	{
475	__uwb_rc_put(rc);
476	}
477	EXPORT_SYMBOL_GPL(uwb_rc_put);