[deliverable/linux.git] / net / rfkill / rfkill.c

/*
 * Copyright (C) 2006 - 2007 Ivo van Doorn
 * Copyright (C) 2007 Dmitry Torokhov
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/workqueue.h>
#include <linux/capability.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/rfkill.h>

MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
MODULE_VERSION("1.0");
MODULE_DESCRIPTION("RF switch support");
MODULE_LICENSE("GPL");

static LIST_HEAD(rfkill_list);	/* list of registered rf switches */
static DEFINE_MUTEX(rfkill_mutex);

static enum rfkill_state rfkill_states[RFKILL_TYPE_MAX];


static void rfkill_led_trigger(struct rfkill *rfkill,
			       enum rfkill_state state)
{
#ifdef CONFIG_RFKILL_LEDS
	struct led_trigger *led = &rfkill->led_trigger;

	if (!led->name)
		return;
	if (state == RFKILL_STATE_OFF)
		led_trigger_event(led, LED_OFF);
	else
		led_trigger_event(led, LED_FULL);
#endif /* CONFIG_RFKILL_LEDS */
}

static int rfkill_toggle_radio(struct rfkill *rfkill,
				enum rfkill_state state)
{
	int retval;

	retval = mutex_lock_interruptible(&rfkill->mutex);
	if (retval)
		return retval;

	if (state != rfkill->state) {
		retval = rfkill->toggle_radio(rfkill->data, state);
		if (!retval) {
			rfkill->state = state;
			rfkill_led_trigger(rfkill, state);
		}
	}

	mutex_unlock(&rfkill->mutex);
	return retval;
}

/**
 * rfkill_switch_all - Toggle state of all switches of given type
 * @type: type of interfaces to be affeceted
 * @state: the new state
 *
 * This function toggles state of all switches of given type unless
 * a specific switch is claimed by userspace in which case it is
 * left alone.
 */

void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
{
	struct rfkill *rfkill;

	mutex_lock(&rfkill_mutex);

	rfkill_states[type] = state;

	list_for_each_entry(rfkill, &rfkill_list, node) {
		if (!rfkill->user_claim)
			rfkill_toggle_radio(rfkill, state);
	}

	mutex_unlock(&rfkill_mutex);
}
EXPORT_SYMBOL(rfkill_switch_all);

static ssize_t rfkill_name_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
	struct rfkill *rfkill = to_rfkill(dev);

	return sprintf(buf, "%s\n", rfkill->name);
}

static ssize_t rfkill_type_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
	struct rfkill *rfkill = to_rfkill(dev);
	const char *type;

	switch (rfkill->type) {
	case RFKILL_TYPE_WLAN:
		type = "wlan";
		break;
	case RFKILL_TYPE_BLUETOOTH:
		type = "bluetooth";
		break;
	case RFKILL_TYPE_UWB:
		type = "ultrawideband";
		break;
	default:
		BUG();
	}

	return sprintf(buf, "%s\n", type);
}

static ssize_t rfkill_state_show(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{
	struct rfkill *rfkill = to_rfkill(dev);

	return sprintf(buf, "%d\n", rfkill->state);
}

static ssize_t rfkill_state_store(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
	struct rfkill *rfkill = to_rfkill(dev);
	unsigned int state = simple_strtoul(buf, NULL, 0);
	int error;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	error = rfkill_toggle_radio(rfkill,
			state ? RFKILL_STATE_ON : RFKILL_STATE_OFF);
	if (error)
		return error;

	return count;
}

static ssize_t rfkill_claim_show(struct device *dev,
				 struct device_attribute *attr,
				 char *buf)
{
	struct rfkill *rfkill = to_rfkill(dev);

	return sprintf(buf, "%d", rfkill->user_claim);
}

static ssize_t rfkill_claim_store(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t count)
{
	struct rfkill *rfkill = to_rfkill(dev);
	bool claim = !!simple_strtoul(buf, NULL, 0);
	int error;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	/*
	 * Take the global lock to make sure the kernel is not in
	 * the middle of rfkill_switch_all
	 */
	error = mutex_lock_interruptible(&rfkill_mutex);
	if (error)
		return error;

	if (rfkill->user_claim_unsupported) {
		error = -EOPNOTSUPP;
		goto out_unlock;
	}
	if (rfkill->user_claim != claim) {
		if (!claim)
			rfkill_toggle_radio(rfkill,
					    rfkill_states[rfkill->type]);
		rfkill->user_claim = claim;
	}

out_unlock:
	mutex_unlock(&rfkill_mutex);

	return error ? error : count;
}

static struct device_attribute rfkill_dev_attrs[] = {
	__ATTR(name, S_IRUGO, rfkill_name_show, NULL),
	__ATTR(type, S_IRUGO, rfkill_type_show, NULL),
	__ATTR(state, S_IRUGO|S_IWUSR, rfkill_state_show, rfkill_state_store),
	__ATTR(claim, S_IRUGO|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
	__ATTR_NULL
};

static void rfkill_release(struct device *dev)
{
	struct rfkill *rfkill = to_rfkill(dev);

	kfree(rfkill);
	module_put(THIS_MODULE);
}

#ifdef CONFIG_PM
static int rfkill_suspend(struct device *dev, pm_message_t state)
{
	struct rfkill *rfkill = to_rfkill(dev);

	if (dev->power.power_state.event != state.event) {
		if (state.event == PM_EVENT_SUSPEND) {
			mutex_lock(&rfkill->mutex);

			if (rfkill->state == RFKILL_STATE_ON)
				rfkill->toggle_radio(rfkill->data,
						     RFKILL_STATE_OFF);

			mutex_unlock(&rfkill->mutex);
		}

		dev->power.power_state = state;
	}

	return 0;
}

static int rfkill_resume(struct device *dev)
{
	struct rfkill *rfkill = to_rfkill(dev);

	if (dev->power.power_state.event != PM_EVENT_ON) {
		mutex_lock(&rfkill->mutex);

		if (rfkill->state == RFKILL_STATE_ON)
			rfkill->toggle_radio(rfkill->data, RFKILL_STATE_ON);

		mutex_unlock(&rfkill->mutex);
	}

	dev->power.power_state = PMSG_ON;
	return 0;
}
#else
#define rfkill_suspend NULL
#define rfkill_resume NULL
#endif

static struct class rfkill_class = {
	.name		= "rfkill",
	.dev_release	= rfkill_release,
	.dev_attrs	= rfkill_dev_attrs,
	.suspend	= rfkill_suspend,
	.resume		= rfkill_resume,
};

static int rfkill_add_switch(struct rfkill *rfkill)
{
	int retval;

	retval = mutex_lock_interruptible(&rfkill_mutex);
	if (retval)
		return retval;

	retval = rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type]);
	if (retval)
		goto out;

	list_add_tail(&rfkill->node, &rfkill_list);

 out:
	mutex_unlock(&rfkill_mutex);
	return retval;
}

static void rfkill_remove_switch(struct rfkill *rfkill)
{
	mutex_lock(&rfkill_mutex);
	list_del_init(&rfkill->node);
	rfkill_toggle_radio(rfkill, RFKILL_STATE_OFF);
	mutex_unlock(&rfkill_mutex);
}

/**
 * rfkill_allocate - allocate memory for rfkill structure.
 * @parent: device that has rf switch on it
 * @type: type of the switch (RFKILL_TYPE_*)
 *
 * This function should be called by the network driver when it needs
 * rfkill structure. Once the structure is allocated the driver shoud
 * finish its initialization by setting name, private data, enable_radio
 * and disable_radio methods and then register it with rfkill_register().
 * NOTE: If registration fails the structure shoudl be freed by calling
 * rfkill_free() otherwise rfkill_unregister() should be used.
 */
struct rfkill *rfkill_allocate(struct device *parent, enum rfkill_type type)
{
	struct rfkill *rfkill;
	struct device *dev;

	rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
	if (!rfkill)
		return NULL;

	mutex_init(&rfkill->mutex);
	INIT_LIST_HEAD(&rfkill->node);
	rfkill->type = type;

	dev = &rfkill->dev;
	dev->class = &rfkill_class;
	dev->parent = parent;
	device_initialize(dev);

	__module_get(THIS_MODULE);

	return rfkill;
}
EXPORT_SYMBOL(rfkill_allocate);

/**
 * rfkill_free - Mark rfkill structure for deletion
 * @rfkill: rfkill structure to be destroyed
 *
 * Decrements reference count of rfkill structure so it is destoryed.
 * Note that rfkill_free() should _not_ be called after rfkill_unregister().
 */
void rfkill_free(struct rfkill *rfkill)
{
	if (rfkill)
		put_device(&rfkill->dev);
}
EXPORT_SYMBOL(rfkill_free);

static void rfkill_led_trigger_register(struct rfkill *rfkill)
{
#ifdef CONFIG_RFKILL_LEDS
	int error;

	rfkill->led_trigger.name = rfkill->dev.bus_id;
	error = led_trigger_register(&rfkill->led_trigger);
	if (error)
		rfkill->led_trigger.name = NULL;
#endif /* CONFIG_RFKILL_LEDS */
}

static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
{
#ifdef CONFIG_RFKILL_LEDS
	if (rfkill->led_trigger.name)
		led_trigger_unregister(&rfkill->led_trigger);
#endif
}

/**
 * rfkill_register - Register a rfkill structure.
 * @rfkill: rfkill structure to be registered
 *
 * This function should be called by the network driver when the rfkill
 * structure needs to be registered. Immediately from registration the
 * switch driver should be able to service calls to toggle_radio.
 */
int rfkill_register(struct rfkill *rfkill)
{
	static atomic_t rfkill_no = ATOMIC_INIT(0);
	struct device *dev = &rfkill->dev;
	int error;

	if (!rfkill->toggle_radio)
		return -EINVAL;

	error = rfkill_add_switch(rfkill);
	if (error)
		return error;

	snprintf(dev->bus_id, sizeof(dev->bus_id),
		 "rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);

	error = device_add(dev);
	if (error) {
		rfkill_remove_switch(rfkill);
		return error;
	}
	rfkill_led_trigger_register(rfkill);

	return 0;
}
EXPORT_SYMBOL(rfkill_register);

/**
 * rfkill_unregister - Uegister a rfkill structure.
 * @rfkill: rfkill structure to be unregistered
 *
 * This function should be called by the network driver during device
 * teardown to destroy rfkill structure. Note that rfkill_free() should
 * _not_ be called after rfkill_unregister().
 */
void rfkill_unregister(struct rfkill *rfkill)
{
	rfkill_led_trigger_unregister(rfkill);
	device_del(&rfkill->dev);
	rfkill_remove_switch(rfkill);
	put_device(&rfkill->dev);
}
EXPORT_SYMBOL(rfkill_unregister);

/*
 * Rfkill module initialization/deinitialization.
 */
static int __init rfkill_init(void)
{
	int error;
	int i;

	for (i = 0; i < ARRAY_SIZE(rfkill_states); i++)
		rfkill_states[i] = RFKILL_STATE_ON;

	error = class_register(&rfkill_class);
	if (error) {
		printk(KERN_ERR "rfkill: unable to register rfkill class\n");
		return error;
	}

	return 0;
}

static void __exit rfkill_exit(void)
{
	class_unregister(&rfkill_class);
}

module_init(rfkill_init);
module_exit(rfkill_exit);
Commit	Line	Data
cf4328cd	1	/*
fe242cfd	2	* Copyright (C) 2006 - 2007 Ivo van Doorn
cf4328cd ID	3	* Copyright (C) 2007 Dmitry Torokhov
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the
	17	* Free Software Foundation, Inc.,
	18	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	19	*/
	20
	21	#include <linux/kernel.h>
	22	#include <linux/module.h>
	23	#include <linux/init.h>
	24	#include <linux/workqueue.h>
	25	#include <linux/capability.h>
	26	#include <linux/list.h>
	27	#include <linux/mutex.h>
	28	#include <linux/rfkill.h>
	29
	30	MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
	31	MODULE_VERSION("1.0");
	32	MODULE_DESCRIPTION("RF switch support");
	33	MODULE_LICENSE("GPL");
	34
	35	static LIST_HEAD(rfkill_list); /* list of registered rf switches */
	36	static DEFINE_MUTEX(rfkill_mutex);
	37
	38	static enum rfkill_state rfkill_states[RFKILL_TYPE_MAX];
	39
135900c1 MB	40
	41	static void rfkill_led_trigger(struct rfkill *rfkill,
	42	enum rfkill_state state)
	43	{
	44	#ifdef CONFIG_RFKILL_LEDS
	45	struct led_trigger *led = &rfkill->led_trigger;
	46
	47	if (!led->name)
	48	return;
	49	if (state == RFKILL_STATE_OFF)
	50	led_trigger_event(led, LED_OFF);
	51	else
	52	led_trigger_event(led, LED_FULL);
	53	#endif /* CONFIG_RFKILL_LEDS */
	54	}
	55
cf4328cd ID	56	static int rfkill_toggle_radio(struct rfkill *rfkill,
	57	enum rfkill_state state)
	58	{
	59	int retval;
	60
	61	retval = mutex_lock_interruptible(&rfkill->mutex);
	62	if (retval)
	63	return retval;
	64
	65	if (state != rfkill->state) {
	66	retval = rfkill->toggle_radio(rfkill->data, state);
135900c1	67	if (!retval) {
cf4328cd	68	rfkill->state = state;
135900c1 MB	69	rfkill_led_trigger(rfkill, state);
135900c1 MB	70	}
cf4328cd ID	71	}
	72
	73	mutex_unlock(&rfkill->mutex);
	74	return retval;
	75	}
	76
	77	/**
	78	* rfkill_switch_all - Toggle state of all switches of given type
	79	* @type: type of interfaces to be affeceted
	80	* @state: the new state
	81	*
	82	* This function toggles state of all switches of given type unless
	83	* a specific switch is claimed by userspace in which case it is
	84	* left alone.
	85	*/
	86
	87	void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
	88	{
	89	struct rfkill *rfkill;
	90
	91	mutex_lock(&rfkill_mutex);
	92
	93	rfkill_states[type] = state;
	94
	95	list_for_each_entry(rfkill, &rfkill_list, node) {
	96	if (!rfkill->user_claim)
	97	rfkill_toggle_radio(rfkill, state);
	98	}
	99
	100	mutex_unlock(&rfkill_mutex);
	101	}
	102	EXPORT_SYMBOL(rfkill_switch_all);
	103
	104	static ssize_t rfkill_name_show(struct device *dev,
	105	struct device_attribute *attr,
	106	char *buf)
	107	{
	108	struct rfkill *rfkill = to_rfkill(dev);
	109
	110	return sprintf(buf, "%s\n", rfkill->name);
	111	}
	112
	113	static ssize_t rfkill_type_show(struct device *dev,
	114	struct device_attribute *attr,
	115	char *buf)
	116	{
	117	struct rfkill *rfkill = to_rfkill(dev);
	118	const char *type;
	119
	120	switch (rfkill->type) {
	121	case RFKILL_TYPE_WLAN:
	122	type = "wlan";
	123	break;
	124	case RFKILL_TYPE_BLUETOOTH:
	125	type = "bluetooth";
	126	break;
e0665486 ID	127	case RFKILL_TYPE_UWB:
	128	type = "ultrawideband";
	129	break;
cf4328cd ID	130	default:
	131	BUG();
	132	}
	133
	134	return sprintf(buf, "%s\n", type);
	135	}
	136
	137	static ssize_t rfkill_state_show(struct device *dev,
	138	struct device_attribute *attr,
	139	char *buf)
	140	{
	141	struct rfkill *rfkill = to_rfkill(dev);
	142
	143	return sprintf(buf, "%d\n", rfkill->state);
	144	}
	145
	146	static ssize_t rfkill_state_store(struct device *dev,
	147	struct device_attribute *attr,
	148	const char *buf, size_t count)
	149	{
	150	struct rfkill *rfkill = to_rfkill(dev);
	151	unsigned int state = simple_strtoul(buf, NULL, 0);
	152	int error;
	153
	154	if (!capable(CAP_NET_ADMIN))
	155	return -EPERM;
	156
	157	error = rfkill_toggle_radio(rfkill,
	158	state ? RFKILL_STATE_ON : RFKILL_STATE_OFF);
	159	if (error)
	160	return error;
	161
	162	return count;
	163	}
	164
	165	static ssize_t rfkill_claim_show(struct device *dev,
	166	struct device_attribute *attr,
	167	char *buf)
	168	{
	169	struct rfkill *rfkill = to_rfkill(dev);
	170
	171	return sprintf(buf, "%d", rfkill->user_claim);
	172	}
	173
	174	static ssize_t rfkill_claim_store(struct device *dev,
	175	struct device_attribute *attr,
	176	const char *buf, size_t count)
	177	{
	178	struct rfkill *rfkill = to_rfkill(dev);
	179	bool claim = !!simple_strtoul(buf, NULL, 0);
	180	int error;
	181
	182	if (!capable(CAP_NET_ADMIN))
	183	return -EPERM;
	184
	185	/*
	186	* Take the global lock to make sure the kernel is not in
	187	* the middle of rfkill_switch_all
	188	*/
	189	error = mutex_lock_interruptible(&rfkill_mutex);
	190	if (error)
	191	return error;
	192
20405c08 MB	193	if (rfkill->user_claim_unsupported) {
	194	error = -EOPNOTSUPP;
	195	goto out_unlock;
	196	}
cf4328cd ID	197	if (rfkill->user_claim != claim) {
	198	if (!claim)
	199	rfkill_toggle_radio(rfkill,
	200	rfkill_states[rfkill->type]);
	201	rfkill->user_claim = claim;
	202	}
	203
20405c08	204	out_unlock:
cf4328cd ID	205	mutex_unlock(&rfkill_mutex);
cf4328cd ID	206
20405c08	207	return error ? error : count;
cf4328cd ID	208	}
	209
	210	static struct device_attribute rfkill_dev_attrs[] = {
	211	__ATTR(name, S_IRUGO, rfkill_name_show, NULL),
	212	__ATTR(type, S_IRUGO, rfkill_type_show, NULL),
c81de6ad	213	__ATTR(state, S_IRUGO\|S_IWUSR, rfkill_state_show, rfkill_state_store),
cf4328cd ID	214	__ATTR(claim, S_IRUGO\|S_IWUSR, rfkill_claim_show, rfkill_claim_store),
	215	__ATTR_NULL
	216	};
	217
	218	static void rfkill_release(struct device *dev)
	219	{
	220	struct rfkill *rfkill = to_rfkill(dev);
	221
	222	kfree(rfkill);
	223	module_put(THIS_MODULE);
	224	}
	225
	226	#ifdef CONFIG_PM
	227	static int rfkill_suspend(struct device *dev, pm_message_t state)
	228	{
	229	struct rfkill *rfkill = to_rfkill(dev);
	230
	231	if (dev->power.power_state.event != state.event) {
	232	if (state.event == PM_EVENT_SUSPEND) {
	233	mutex_lock(&rfkill->mutex);
	234
	235	if (rfkill->state == RFKILL_STATE_ON)
	236	rfkill->toggle_radio(rfkill->data,
	237	RFKILL_STATE_OFF);
	238
	239	mutex_unlock(&rfkill->mutex);
	240	}
	241
	242	dev->power.power_state = state;
	243	}
	244
	245	return 0;
	246	}
	247
	248	static int rfkill_resume(struct device *dev)
	249	{
	250	struct rfkill *rfkill = to_rfkill(dev);
	251
	252	if (dev->power.power_state.event != PM_EVENT_ON) {
	253	mutex_lock(&rfkill->mutex);
	254
	255	if (rfkill->state == RFKILL_STATE_ON)
	256	rfkill->toggle_radio(rfkill->data, RFKILL_STATE_ON);
	257
	258	mutex_unlock(&rfkill->mutex);
	259	}
	260
	261	dev->power.power_state = PMSG_ON;
	262	return 0;
	263	}
	264	#else
	265	#define rfkill_suspend NULL
	266	#define rfkill_resume NULL
	267	#endif
	268
	269	static struct class rfkill_class = {
	270	.name = "rfkill",
	271	.dev_release = rfkill_release,
	272	.dev_attrs = rfkill_dev_attrs,
	273	.suspend = rfkill_suspend,
	274	.resume = rfkill_resume,
	275	};
	276
	277	static int rfkill_add_switch(struct rfkill *rfkill)
278	{
279	int retval;
280
281	retval = mutex_lock_interruptible(&rfkill_mutex);
282	if (retval)
283	return retval;
284
285	retval = rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type]);
286	if (retval)
287	goto out;
288
289	list_add_tail(&rfkill->node, &rfkill_list);
290
291	out:
292	mutex_unlock(&rfkill_mutex);
293	return retval;
294	}
295
296	static void rfkill_remove_switch(struct rfkill *rfkill)
297	{
298	mutex_lock(&rfkill_mutex);
299	list_del_init(&rfkill->node);
300	rfkill_toggle_radio(rfkill, RFKILL_STATE_OFF);
301	mutex_unlock(&rfkill_mutex);
302	}
303
304	/**
305	* rfkill_allocate - allocate memory for rfkill structure.
306	* @parent: device that has rf switch on it
234a0ca6	307	* @type: type of the switch (RFKILL_TYPE_*)
cf4328cd ID	308	*
	309	* This function should be called by the network driver when it needs
	310	* rfkill structure. Once the structure is allocated the driver shoud
	311	* finish its initialization by setting name, private data, enable_radio
	312	* and disable_radio methods and then register it with rfkill_register().
	313	* NOTE: If registration fails the structure shoudl be freed by calling
	314	* rfkill_free() otherwise rfkill_unregister() should be used.
	315	*/
	316	struct rfkill rfkill_allocate(struct device parent, enum rfkill_type type)
	317	{
	318	struct rfkill *rfkill;
	319	struct device *dev;
	320
	321	rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
d007da1f	322	if (!rfkill)
cf4328cd ID	323	return NULL;
	324
	325	mutex_init(&rfkill->mutex);
	326	INIT_LIST_HEAD(&rfkill->node);
	327	rfkill->type = type;
	328
	329	dev = &rfkill->dev;
	330	dev->class = &rfkill_class;
	331	dev->parent = parent;
	332	device_initialize(dev);
	333
	334	__module_get(THIS_MODULE);
	335
	336	return rfkill;
	337	}
	338	EXPORT_SYMBOL(rfkill_allocate);
	339
	340	/**
	341	* rfkill_free - Mark rfkill structure for deletion
	342	* @rfkill: rfkill structure to be destroyed
	343	*
	344	* Decrements reference count of rfkill structure so it is destoryed.
	345	* Note that rfkill_free() should _not_ be called after rfkill_unregister().
	346	*/
	347	void rfkill_free(struct rfkill *rfkill)
	348	{
	349	if (rfkill)
	350	put_device(&rfkill->dev);
	351	}
	352	EXPORT_SYMBOL(rfkill_free);
	353
135900c1 MB	354	static void rfkill_led_trigger_register(struct rfkill *rfkill)
	355	{
	356	#ifdef CONFIG_RFKILL_LEDS
	357	int error;
	358
	359	rfkill->led_trigger.name = rfkill->dev.bus_id;
	360	error = led_trigger_register(&rfkill->led_trigger);
	361	if (error)
	362	rfkill->led_trigger.name = NULL;
	363	#endif /* CONFIG_RFKILL_LEDS */
	364	}
	365
	366	static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
	367	{
	368	#ifdef CONFIG_RFKILL_LEDS
	369	if (rfkill->led_trigger.name)
	370	led_trigger_unregister(&rfkill->led_trigger);
	371	#endif
	372	}
	373
cf4328cd ID	374	/**
	375	* rfkill_register - Register a rfkill structure.
	376	* @rfkill: rfkill structure to be registered
	377	*
	378	* This function should be called by the network driver when the rfkill
	379	* structure needs to be registered. Immediately from registration the
	380	* switch driver should be able to service calls to toggle_radio.
	381	*/
	382	int rfkill_register(struct rfkill *rfkill)
	383	{
	384	static atomic_t rfkill_no = ATOMIC_INIT(0);
	385	struct device *dev = &rfkill->dev;
	386	int error;
	387
	388	if (!rfkill->toggle_radio)
	389	return -EINVAL;
	390
	391	error = rfkill_add_switch(rfkill);
	392	if (error)
	393	return error;
	394
	395	snprintf(dev->bus_id, sizeof(dev->bus_id),
	396	"rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
	397
	398	error = device_add(dev);
	399	if (error) {
	400	rfkill_remove_switch(rfkill);
	401	return error;
	402	}
135900c1	403	rfkill_led_trigger_register(rfkill);
cf4328cd ID	404
	405	return 0;
	406	}
	407	EXPORT_SYMBOL(rfkill_register);
	408
	409	/**
	410	* rfkill_unregister - Uegister a rfkill structure.
	411	* @rfkill: rfkill structure to be unregistered
	412	*
	413	* This function should be called by the network driver during device
	414	* teardown to destroy rfkill structure. Note that rfkill_free() should
	415	* _not_ be called after rfkill_unregister().
	416	*/
	417	void rfkill_unregister(struct rfkill *rfkill)
	418	{
135900c1	419	rfkill_led_trigger_unregister(rfkill);
cf4328cd ID	420	device_del(&rfkill->dev);
	421	rfkill_remove_switch(rfkill);
	422	put_device(&rfkill->dev);
	423	}
	424	EXPORT_SYMBOL(rfkill_unregister);
	425
	426	/*
	427	* Rfkill module initialization/deinitialization.
	428	*/
	429	static int __init rfkill_init(void)
	430	{
	431	int error;
	432	int i;
	433
	434	for (i = 0; i < ARRAY_SIZE(rfkill_states); i++)
	435	rfkill_states[i] = RFKILL_STATE_ON;
	436
	437	error = class_register(&rfkill_class);
	438	if (error) {
	439	printk(KERN_ERR "rfkill: unable to register rfkill class\n");
	440	return error;
	441	}
	442
	443	return 0;
	444	}
	445
	446	static void __exit rfkill_exit(void)
	447	{
	448	class_unregister(&rfkill_class);
	449	}
	450
	451	module_init(rfkill_init);
	452	module_exit(rfkill_exit);