[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>

/* Get declaration of rfkill_switch_all() to shut up sparse. */
#include "rfkill-input.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 = 0;

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

	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;

	if (mutex_lock_interruptible(&rfkill->mutex))
		return -ERESTARTSYS;
	error = rfkill_toggle_radio(rfkill,
			state ? RFKILL_STATE_ON : RFKILL_STATE_OFF);
	mutex_unlock(&rfkill->mutex);

	return error ? error : 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 error;

	mutex_lock(&rfkill_mutex);

	error = rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type]);
	if (!error)
		list_add_tail(&rfkill->node, &rfkill_list);

	mutex_unlock(&rfkill_mutex);

	return error;
}

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;
	if (rfkill->type >= RFKILL_TYPE_MAX)
		return -EINVAL;

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

	rfkill_led_trigger_register(rfkill);

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

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

	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)
{
	device_del(&rfkill->dev);
	rfkill_remove_switch(rfkill);
	rfkill_led_trigger_unregister(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);
}

subsys_initcall(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
27366223 MB	30	/* Get declaration of rfkill_switch_all() to shut up sparse. */
	31	#include "rfkill-input.h"
	32
	33
cf4328cd ID	34	MODULE_AUTHOR("Ivo van Doorn <IvDoorn@gmail.com>");
	35	MODULE_VERSION("1.0");
	36	MODULE_DESCRIPTION("RF switch support");
	37	MODULE_LICENSE("GPL");
	38
	39	static LIST_HEAD(rfkill_list); /* list of registered rf switches */
	40	static DEFINE_MUTEX(rfkill_mutex);
	41
	42	static enum rfkill_state rfkill_states[RFKILL_TYPE_MAX];
	43
135900c1 MB	44
	45	static void rfkill_led_trigger(struct rfkill *rfkill,
	46	enum rfkill_state state)
	47	{
	48	#ifdef CONFIG_RFKILL_LEDS
	49	struct led_trigger *led = &rfkill->led_trigger;
	50
	51	if (!led->name)
	52	return;
	53	if (state == RFKILL_STATE_OFF)
	54	led_trigger_event(led, LED_OFF);
	55	else
	56	led_trigger_event(led, LED_FULL);
	57	#endif /* CONFIG_RFKILL_LEDS */
	58	}
	59
cf4328cd ID	60	static int rfkill_toggle_radio(struct rfkill *rfkill,
	61	enum rfkill_state state)
	62	{
7f4c5341	63	int retval = 0;
cf4328cd ID	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	}
cf4328cd ID	72
cf4328cd ID	73	return retval;
	74	}
	75
	76	/**
	77	* rfkill_switch_all - Toggle state of all switches of given type
	78	* @type: type of interfaces to be affeceted
	79	* @state: the new state
	80	*
	81	* This function toggles state of all switches of given type unless
	82	* a specific switch is claimed by userspace in which case it is
	83	* left alone.
	84	*/
	85
	86	void rfkill_switch_all(enum rfkill_type type, enum rfkill_state state)
	87	{
	88	struct rfkill *rfkill;
	89
	90	mutex_lock(&rfkill_mutex);
	91
	92	rfkill_states[type] = state;
	93
	94	list_for_each_entry(rfkill, &rfkill_list, node) {
	95	if (!rfkill->user_claim)
	96	rfkill_toggle_radio(rfkill, state);
	97	}
	98
	99	mutex_unlock(&rfkill_mutex);
	100	}
	101	EXPORT_SYMBOL(rfkill_switch_all);
	102
	103	static ssize_t rfkill_name_show(struct device *dev,
	104	struct device_attribute *attr,
	105	char *buf)
	106	{
	107	struct rfkill *rfkill = to_rfkill(dev);
	108
	109	return sprintf(buf, "%s\n", rfkill->name);
	110	}
	111
	112	static ssize_t rfkill_type_show(struct device *dev,
	113	struct device_attribute *attr,
	114	char *buf)
	115	{
	116	struct rfkill *rfkill = to_rfkill(dev);
	117	const char *type;
	118
	119	switch (rfkill->type) {
	120	case RFKILL_TYPE_WLAN:
	121	type = "wlan";
	122	break;
	123	case RFKILL_TYPE_BLUETOOTH:
	124	type = "bluetooth";
	125	break;
e0665486 ID	126	case RFKILL_TYPE_UWB:
	127	type = "ultrawideband";
	128	break;
cf4328cd ID	129	default:
	130	BUG();
	131	}
	132
	133	return sprintf(buf, "%s\n", type);
	134	}
	135
	136	static ssize_t rfkill_state_show(struct device *dev,
	137	struct device_attribute *attr,
	138	char *buf)
	139	{
	140	struct rfkill *rfkill = to_rfkill(dev);
	141
	142	return sprintf(buf, "%d\n", rfkill->state);
	143	}
	144
	145	static ssize_t rfkill_state_store(struct device *dev,
	146	struct device_attribute *attr,
	147	const char *buf, size_t count)
	148	{
	149	struct rfkill *rfkill = to_rfkill(dev);
	150	unsigned int state = simple_strtoul(buf, NULL, 0);
	151	int error;
	152
	153	if (!capable(CAP_NET_ADMIN))
	154	return -EPERM;
	155
7f4c5341 MB	156	if (mutex_lock_interruptible(&rfkill->mutex))
7f4c5341 MB	157	return -ERESTARTSYS;
cf4328cd ID	158	error = rfkill_toggle_radio(rfkill,
cf4328cd ID	159	state ? RFKILL_STATE_ON : RFKILL_STATE_OFF);
7f4c5341	160	mutex_unlock(&rfkill->mutex);
cf4328cd	161
7f4c5341	162	return error ? error : count;
cf4328cd ID	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	{
7319f1e6	279	int error;
cf4328cd	280
7319f1e6	281	mutex_lock(&rfkill_mutex);
cf4328cd	282
7319f1e6 MB	283	error = rfkill_toggle_radio(rfkill, rfkill_states[rfkill->type]);
	284	if (!error)
	285	list_add_tail(&rfkill->node, &rfkill_list);
cf4328cd	286
cf4328cd	287	mutex_unlock(&rfkill_mutex);
7319f1e6 MB	288
7319f1e6 MB	289	return error;
cf4328cd ID	290	}
	291
	292	static void rfkill_remove_switch(struct rfkill *rfkill)
	293	{
	294	mutex_lock(&rfkill_mutex);
	295	list_del_init(&rfkill->node);
	296	rfkill_toggle_radio(rfkill, RFKILL_STATE_OFF);
	297	mutex_unlock(&rfkill_mutex);
	298	}
	299
	300	/**
	301	* rfkill_allocate - allocate memory for rfkill structure.
	302	* @parent: device that has rf switch on it
234a0ca6	303	* @type: type of the switch (RFKILL_TYPE_*)
cf4328cd ID	304	*
	305	* This function should be called by the network driver when it needs
	306	* rfkill structure. Once the structure is allocated the driver shoud
	307	* finish its initialization by setting name, private data, enable_radio
	308	* and disable_radio methods and then register it with rfkill_register().
	309	* NOTE: If registration fails the structure shoudl be freed by calling
	310	* rfkill_free() otherwise rfkill_unregister() should be used.
	311	*/
	312	struct rfkill rfkill_allocate(struct device parent, enum rfkill_type type)
	313	{
	314	struct rfkill *rfkill;
	315	struct device *dev;
	316
	317	rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
d007da1f	318	if (!rfkill)
cf4328cd ID	319	return NULL;
	320
	321	mutex_init(&rfkill->mutex);
	322	INIT_LIST_HEAD(&rfkill->node);
	323	rfkill->type = type;
	324
	325	dev = &rfkill->dev;
	326	dev->class = &rfkill_class;
	327	dev->parent = parent;
	328	device_initialize(dev);
	329
	330	__module_get(THIS_MODULE);
	331
	332	return rfkill;
	333	}
	334	EXPORT_SYMBOL(rfkill_allocate);
	335
	336	/**
	337	* rfkill_free - Mark rfkill structure for deletion
	338	* @rfkill: rfkill structure to be destroyed
	339	*
	340	* Decrements reference count of rfkill structure so it is destoryed.
	341	* Note that rfkill_free() should _not_ be called after rfkill_unregister().
	342	*/
	343	void rfkill_free(struct rfkill *rfkill)
	344	{
	345	if (rfkill)
	346	put_device(&rfkill->dev);
	347	}
	348	EXPORT_SYMBOL(rfkill_free);
	349
135900c1 MB	350	static void rfkill_led_trigger_register(struct rfkill *rfkill)
	351	{
	352	#ifdef CONFIG_RFKILL_LEDS
	353	int error;
	354
	355	rfkill->led_trigger.name = rfkill->dev.bus_id;
	356	error = led_trigger_register(&rfkill->led_trigger);
	357	if (error)
	358	rfkill->led_trigger.name = NULL;
	359	#endif /* CONFIG_RFKILL_LEDS */
	360	}
	361
	362	static void rfkill_led_trigger_unregister(struct rfkill *rfkill)
	363	{
	364	#ifdef CONFIG_RFKILL_LEDS
	365	if (rfkill->led_trigger.name)
	366	led_trigger_unregister(&rfkill->led_trigger);
	367	#endif
	368	}
	369
cf4328cd ID	370	/**
	371	* rfkill_register - Register a rfkill structure.
	372	* @rfkill: rfkill structure to be registered
	373	*
	374	* This function should be called by the network driver when the rfkill
	375	* structure needs to be registered. Immediately from registration the
	376	* switch driver should be able to service calls to toggle_radio.
	377	*/
	378	int rfkill_register(struct rfkill *rfkill)
	379	{
	380	static atomic_t rfkill_no = ATOMIC_INIT(0);
	381	struct device *dev = &rfkill->dev;
	382	int error;
	383
	384	if (!rfkill->toggle_radio)
	385	return -EINVAL;
7319f1e6 MB	386	if (rfkill->type >= RFKILL_TYPE_MAX)
7319f1e6 MB	387	return -EINVAL;
cf4328cd	388
8a8f1c04 MB	389	snprintf(dev->bus_id, sizeof(dev->bus_id),
	390	"rfkill%ld", (long)atomic_inc_return(&rfkill_no) - 1);
	391
	392	rfkill_led_trigger_register(rfkill);
	393
cf4328cd ID	394	error = rfkill_add_switch(rfkill);
	395	if (error)
	396	return error;
	397
cf4328cd ID	398	error = device_add(dev);
	399	if (error) {
	400	rfkill_remove_switch(rfkill);
	401	return error;
	402	}
	403
	404	return 0;
	405	}
	406	EXPORT_SYMBOL(rfkill_register);
	407
	408	/**
	409	* rfkill_unregister - Uegister a rfkill structure.
	410	* @rfkill: rfkill structure to be unregistered
	411	*
	412	* This function should be called by the network driver during device
	413	* teardown to destroy rfkill structure. Note that rfkill_free() should
	414	* _not_ be called after rfkill_unregister().
	415	*/
	416	void rfkill_unregister(struct rfkill *rfkill)
	417	{
	418	device_del(&rfkill->dev);
	419	rfkill_remove_switch(rfkill);
8a8f1c04	420	rfkill_led_trigger_unregister(rfkill);
cf4328cd ID	421	put_device(&rfkill->dev);
	422	}
	423	EXPORT_SYMBOL(rfkill_unregister);
	424
	425	/*
	426	* Rfkill module initialization/deinitialization.
	427	*/
	428	static int __init rfkill_init(void)
	429	{
	430	int error;
	431	int i;
	432
	433	for (i = 0; i < ARRAY_SIZE(rfkill_states); i++)
	434	rfkill_states[i] = RFKILL_STATE_ON;
	435
	436	error = class_register(&rfkill_class);
	437	if (error) {
	438	printk(KERN_ERR "rfkill: unable to register rfkill class\n");
	439	return error;
	440	}
	441
	442	return 0;
	443	}
	444
	445	static void __exit rfkill_exit(void)
	446	{
	447	class_unregister(&rfkill_class);
	448	}
	449
2bf236d5	450	subsys_initcall(rfkill_init);
cf4328cd	451	module_exit(rfkill_exit);